5.02. Справочник по Python

В РАЗРАБОТКЕНЕ ДЛЯ НОВИЧКОВНЕ ОБЯЗАТЕЛЬНО

Разработчику Архитектору

📘 Часть 1. Ядро языка Python

Версия справочника соответствует CPython 3.12 (актуальная LTS-версия на 2025 год).

1.1 Встроенные типы

Python определяет следующие встроенные типы. Все они реализованы на уровне интерпретатора и доступны без импорта.

`NoneType`

Единственный экземпляр — None.

Атрибуты: отсутствуют
Методы: отсутствуют
Свойства:
- __class__ — <class 'NoneType'>
- __bool__() возвращает False
- __repr__() возвращает 'None'

`bool`

Имеет два экземпляра: True, False. Наследует от int.

Атрибуты: отсутствуют
Методы: наследует все методы int, но не предоставляет новых
Свойства:
- __class__ — <class 'bool'>
- __new__(cls, x=False) — создаёт True, если x истинно, иначе False
- __abs__(), __add__(), __and__(), __eq__(), __float__(), __int__(), __invert__(), __or__(), __repr__(), __str__() — определены явно
- Унарные и бинарные операции с bool возвращают int, если результат не может быть представлен как bool (например, True + True → 2)

`int`

Произвольной точности целое число.

Атрибуты:
- real, imag, numerator, denominator — свойства, возвращающие сам объект (для целых чисел)
Методы:
- bit_length() — количество бит, необходимых для представления абсолютного значения, без учёта знака
- to_bytes(length, byteorder, *, signed=False) — сериализация в bytes
- from_bytes(bytes, byteorder, *, signed=False) — конструктор класса из bytes
- as_integer_ratio() — возвращает кортеж (self, 1)
- __ceil__(), __floor__(), __round__(), __trunc__() — совместимость с numbers.Integral
Свойства:
- __class__ — <class 'int'>
- __new__(cls, x=0, base=10) — поддерживает строку с указанием основания
- Допустимые основания: от 2 до 36 включительно
- Бинарные операции: + - * // % divmod ** << >> & | ^
- Бинарные операции с плавающей запятой возвращают float
- Операции сравнения: < <= == != >= >

`float`

Число с плавающей запятой двойной точности (IEEE 754 binary64).

Атрибуты:
- real, imag, is_integer() — возвращает True, если значение целое
Методы:
- as_integer_ratio() — возвращает (n, d), n/d == self, d > 0
- hex() — шестнадцатеричная строка вида 0x1.8p+1
- fromhex(s) — конструктор из шестнадцатеричной строки
Свойства:
- __class__ — <class 'float'>
- __new__(cls, x=0.0) — преобразует строки, целые, другие float
- Специальные значения: inf, -inf, nan (получаются через float('inf'), float('nan'))
- nan == nan возвращает False; math.isnan() используется для проверки
- Все операции с nan (кроме !=) возвращают nan
- Операции с inf: inf + inf == inf, inf - inf == nan, inf / inf == nan, 0 * inf == nan

`complex`

Комплексное число: real + imag * 1j

Атрибуты:
- real, imag — вещественная и мнимая части (float)
Методы:
- conjugate() — возвращает комплексно-сопряжённое
- __abs__() — модуль числа (sqrt(real² + imag²))
Свойства:
- __class__ — <class 'complex'>
- __new__(cls, real=0.0, imag=0.0) — принимает числа или строки вида '3+4j'
- Строковый литерал: 3+4j, 1j, 5. (вещественное), но не j
- Нельзя сравнивать на <, <=, >, >=
- Поддерживает: + - * / // % **
- Целочисленное деление // и деление по модулю % не определены (выбрасывают TypeError)

`str`

Неизменяемая последовательность Unicode-символов (UTF-8 внутри).

Атрибуты: отсутствуют (все методы — функции)
Методы (выборочно, наиболее употребительные; всего — 48):
- capitalize()
- casefold()
- center(width[, fillchar])
- count(sub[, start[, end]])
- encode(encoding='utf-8', errors='strict')
- endswith(suffix[, start[, end]])
- expandtabs(tabsize=8)
- find(sub[, start[, end]])
- format(*args, **kwargs)
- format_map(mapping)
- index(sub[, start[, end]])
- isalnum(), isalpha(), isascii(), isdecimal(), isdigit(), isidentifier(), islower(), isnumeric(), isprintable(), isspace(), istitle(), isupper()
- join(iterable)
- ljust(width[, fillchar])
- lower()
- lstrip([chars])
- maketrans(x[, y[, z]]) — статический метод, возвращает таблицу для translate()
- partition(sep)
- removeprefix(prefix), removesuffix(suffix)
- replace(old, new[, count])
- rfind(sub[, start[, end]])
- rindex(sub[, start[, end]])
- rjust(width[, fillchar])
- rpartition(sep)
- rsplit(sep=None, maxsplit=-1)
- rstrip([chars])
- split(sep=None, maxsplit=-1)
- splitlines([keepends])
- startswith(prefix[, start[, end]])
- strip([chars])
- swapcase()
- title()
- translate(table)
- upper()
- zfill(width)
Свойства:
- __class__ — <class 'str'>
- __new__(cls, object='') — преобразует объект в строку
- __getitem__(key) — возвращает str длины 1
- __iter__() — итератор по символам
- __len__() — длина в символах (не в байтах)
- __contains__(sub) — проверка подстроки
- __add__, __mul__, __rmul__ — конкатенация и повторение
- __mod__ — форматирование по %
- Литералы: ', ", ''', """, r'', f'', rf'', fr''
- Escape-последовательности: \n \r \t \\ \' \" \xhh \uhhhh \Uhhhhhhhh \N{name}
- Строки — хэшируемы

`bytes`

Неизменяемая последовательность байтов (целых от 0 до 255).

Атрибуты: отсутствуют
Методы (все аналогичны str, но для байтов):
- capitalize(), center(), count(), decode(encoding='utf-8', errors='strict'), endswith(), expandtabs(), find(), hex(), index(), isalnum(), isalpha(), isascii(), isdigit(), islower(), isspace(), istitle(), isupper(), join(), ljust(), lower(), lstrip(), maketrans(from, to) — статический, возвращает bytes таблицу
- partition(), removeprefix(), removesuffix(), replace(), rfind(), rindex(), rjust(), rpartition(), rsplit(), rstrip(), split(), splitlines(), startswith(), strip(), swapcase(), title(), translate(table), upper(), zfill()
- fromhex(s) — статический метод
Свойства:
- __class__ — <class 'bytes'>
- __new__(cls, source=b'', encoding=None, errors='strict') — принимает int, str (с encoding), Iterable[int], bytes-like
- __getitem__, __iter__, __len__, __contains__, __add__, __mul__, __rmul__ — как у str
- Литералы: b'', br'', rb''
- Escape-последовательности: только ASCII (\n \r \t \\ \' \" \xhh)
- Не поддерживает format(), format_map()
- Хэшируем

`bytearray`

Изменяемая последовательность байтов.

Атрибуты: отсутствуют
Методы:
- Все методы bytes, плюс изменяющие:
  - append(x), clear(), copy(), extend(iterable), insert(i, x), pop([i]), remove(value), reverse()
  - __setitem__, __delitem__, __iadd__, __imul__
Свойства:
- __class__ — <class 'bytearray'>
- __new__(cls, source=b'', encoding=None, errors='strict') — как bytes
- Не хэшируем

`memoryview`

Представление буферного протокола без копирования.

Атрибуты:
- format — строка формата (например, 'B', 'd', '3f')
- itemsize — размер одного элемента в байтах
- ndim — количество измерений
- readonly — bool
- shape — кортеж размеров, None для одномерных неизвестной длины
- strides — кортеж шагов, None при отсутствии
- suboffsets — кортеж смещений для вложенных структур
- c_contiguous, f_contiguous, contiguous — флаги расположения в памяти
Методы:
- tobytes()
- tolist()
- toreadonly()
- cast(format[, shape])
- release()
Свойства:
- __class__ — <class 'memoryview'>
- __new__(cls, obj) — obj должен реализовывать буферный протокол
- __getitem__, __setitem__ (если не readonly)
- __len__, __eq__, __hash__ (хэш равен None, если не readonly)
- Поддерживает нарезку, возвращает memoryview

`list`

Изменяемая упорядоченная последовательность произвольных объектов.

Атрибуты: отсутствуют
Методы:
- append(x), clear(), copy(), count(x), extend(iterable), index(x[, start[, end]]), insert(i, x), pop([i]), remove(x), reverse(), sort(*, key=None, reverse=False)
Свойства:
- __class__ — <class 'list'>
- __new__(cls, iterable=())
- __getitem__, __setitem__, __delitem__, __len__, __iter__, __contains__
- __add__, __iadd__, __mul__, __imul__, __rmul__
- Не хэшируем
- Реализует collections.abc.MutableSequence

`tuple`

Неизменяемая упорядоченная последовательность произвольных объектов.

Атрибуты: отсутствуют
Методы:
- count(x), index(x[, start[, end]])
Свойства:
- __class__ — <class 'tuple'>
- __new__(cls, iterable=())
- __getitem__, __len__, __iter__, __contains__, __add__, __mul__, __rmul__
- Хэшируем (если все элементы хэшируемы)

`range`

Неизменяемая арифметическая прогрессия целых чисел.

Атрибуты:
- start, stop, step — int
Методы:
- count(value), index(value)
Свойства:
- __class__ — <class 'range'>
- __new__(cls, stop) или __new__(cls, start, stop[, step])
- __getitem__, __len__, __iter__, __contains__, __reversed__
- Хэшируем
- Постоянный объём памяти (не хранит все элементы)
- Поддерживает срезы: range(...)[::k] → новый range

`dict`

Изменяемое отображение «ключ → значение». Порядок вставки сохраняется (с Python 3.7 как гарантия).

Атрибуты: отсутствуют
Методы:
- clear(), copy(), fromkeys(iterable[, value]) — статический
- get(key[, default]), items(), keys(), pop(key[, default]), popitem(), setdefault(key[, default]), update([other]), values()
- __class_getitem__() — поддержка dict[str, int] для аннотаций
Свойства:
- __class__ — <class 'dict'>
- __new__(cls, other=None, **kwargs) — принимает отображения, итераторы пар, ключевые аргументы
- __getitem__, __setitem__, __delitem__, __len__, __iter__, __contains__
- __or__, __ror__, __ior__ (с Python 3.9) — объединение
- Не хэшируем
- Порог перестроения хэш-таблицы: ~2/3 заполнения
- Хэш-функция ключа: hash(key), должен быть хэшируемым
- Операции in, [], get, setdefault имеют амортизированную O(1) сложность

`set`

Изменяемое неупорядоченное множество хэшируемых объектов без дубликатов.

Атрибуты: отсутствуют
Методы:
- add(elem), clear(), copy(), difference(*others), difference_update(*others), discard(elem), intersection(*others), intersection_update(*others), isdisjoint(other), issubset(other), issuperset(other), pop(), remove(elem), symmetric_difference(other), symmetric_difference_update(other), union(*others), update(*others)
Свойства:
- __class__ — <class 'set'>
- __new__(cls, iterable=())
- __len__, __iter__, __contains__, __ior__, __iand__, __ixor__, __isub__
- Не хэшируем
- Литералы: {1, 2, 3}, {} — не пустой set, а пустой dict; для set() требуется вызов конструктора
- Операции in, add, discard, remove — амортизированная O(1)

`frozenset`

Неизменяемое множество.

Атрибуты: отсутствуют
Методы: все как у set, кроме изменяющих (add, discard, pop, и т.д.)
Свойства:
- __class__ — <class 'frozenset'>
- __new__(cls, iterable=())
- __len__, __iter__, __contains__, __or__, __and__, __xor__, __sub__
- Хэшируем
- Литералов нет — только через конструктор

1.2 Встроенные вызываемые объекты и служебные типы

`type`

Метакласс по умолчанию.

Атрибуты:
- __name__ — имя класса (str)
- __qualname__ — квалифицированное имя (str)
- __module__ — имя модуля, в котором определён класс
- __bases__ — кортеж базовых классов
- __mro__ — кортеж, порядок разрешения методов
- __subclasses__() — список прямых подклассов
- __dict__ — mappingproxy с атрибутами класса
- __annotations__ — словарь аннотаций типов полей класса (если есть)
Методы:
- __call__() — создаёт экземпляр класса (вызывает __new__, затем __init__)
- __instancecheck__(instance) — используется в isinstance()
- __subclasscheck__(subclass) — используется в issubclass()
- mro() — возвращает __mro__
Свойства:
- __new__(cls, name, bases, dict, **kwargs) — конструктор класса
- Любой класс — экземпляр type или его подкласса
- Любой экземпляр класса — объект, чей type(obj) — класс
- Поддерживает наследование, множественное наследование, динамическое создание (type('A', (), {}))

`function`

Объект, создаваемый при выполнении def.

Атрибуты:
- __name__, __qualname__, __module__, __doc__
- __annotations__ — словарь аннотаций параметров и возвращаемого значения
- __defaults__ — кортеж значений по умолчанию (позиционные, справа)
- __kwdefaults__ — словарь значений по умолчанию для ключевых параметров
- __code__ — объект code, байт-код функции
- __globals__ — словарь глобальных переменных модуля
- __closure__ — кортеж ячеек (cell), замыкание; None, если нет
- __dict__ — пользовательский словарь (изменяемый, для метаданных)
Свойства:
- __call__(*args, **kwargs) — вызов функции
- Поддерживает pickle, если не замыкает непикл-объекты
- Функции — хэшируемы

`builtin_function_or_method`

Объекты, реализованные на уровне C (например, len, print, int.bit_length).

Атрибуты:
- __name__, __doc__, __module__
- __self__ — для методов: экземпляр или класс, к которому привязан; у встроенных функций — None
Свойства:
- __call__ — вызов реализован в C
- Не имеет __code__, __defaults__, __closure__, __dict__
- Хэшируем

`method`

Метод экземпляра: вызов obj.method создаёт method, где __func__ — функция из класса, __self__ — obj.

Атрибуты:
- __func__ — исходная функция (function)
- __self__ — экземпляр
- __doc__, __name__, __module__, __annotations__ — проксируются из __func__
Свойства:
- __call__() — вызывает __func__(__self__, *args, **kwargs)
- Хэшируем, если __self__ и __func__ хэшируемы

`classmethod`

Дескриптор, возвращающий method, где __self__ — класс.

Атрибуты:
- __func__ — функция, обёрнутая в @classmethod
Свойства:
- __get__(instance, owner) — возвращает method(__func__, owner)
- Вызываем напрямую: cls.method() → __func__(cls, ...)

`staticmethod`

Дескриптор, возвращающий исходную функцию без привязки.

Атрибуты:
- __func__ — функция
Свойства:
- __get__(instance, owner) — возвращает __func__
- Вызов: cls.method() или obj.method() → __func__(...)

`property`

Дескриптор для управления доступом к атрибуту.

Атрибуты:
- fget, fset, fdel, doc — функции/строка
Методы:
- getter(func), setter(func), deleter(func) — возвращают новый property
Свойства:
- __get__(obj, owner) — вызывает fget(obj)
- __set__(obj, value) — вызывает fset(obj, value)
- __delete__(obj) — вызывает fdel(obj)
- Поддерживает декораторный синтаксис:
```
@property
def x(self): ...
@x.setter
def x(self, v): ...
```

`module`

Объект модуля (например, import math → math).

Атрибуты:
- __name__ — полное имя ('os.path', '__main__')
- __doc__ — строка документации модуля
- __package__ — имя пакета (или '' для верхнего уровня)
- __loader__, __spec__ — объекты загрузчика и спецификации
- __file__ — путь к .py (может отсутствовать)
- __cached__ — путь к .pyc
- __dict__ — словарь атрибутов модуля
Свойства:
- Все глобальные имена в модуле — атрибуты объекта module
- Поддерживает pickle (по имени)

`ellipsis`

Единственный экземпляр — ... (синтаксический литерал).

Атрибуты: отсутствуют
Использование:
- В типах: Tuple[int, ...]
- В срезах: a[...] для многомерных массивов (NumPy)
- Заглушка в заглушках (например, в abc.ABC)

`slice`

Объект среза ([start:stop:step]).

Атрибуты:
- start, stop, step — значения (None, если не указаны)
Методы:
- indices(length) — возвращает (start, stop, step), приведённые к length
Свойства:
- __new__(cls, stop) или __new__(cls, start, stop[, step])
- Хэшируем
- slice(None) эквивалентен [:]

`mappingproxy`

Только для чтения обёртка над dict (type.__dict__).

Атрибуты: отсутствуют
Методы:
- Все методы dict, кроме изменяющих (clear, update, __setitem__, и т.д.)
Свойства:
- __new__(cls, mapping)
- Динамически отражает изменения в оригинальном dict
- Хэшируем (только если оригинальный dict неизменяем, но в Python dict не хэшируем, поэтому mappingproxy не хэшируем)

`weakref.ref`

Слабая ссылка на объект.

Атрибуты: отсутствуют
Методы:
- __call__() — возвращает объект, если жив, иначе None
- __hash__() — хэш объекта, на который ссылается
Свойства:
- __new__(cls, obj[, callback])
- callback вызывается при сборке мусора объекта obj
- Не препятствует сборке мусора
- Нельзя создать для int, str, tuple, None, bool, type, function, если они не имеют __weakref__ в слотах

`weakref.proxy`

Прозрачная слабая ссылка (доступ как к оригиналу).

Атрибуты, методы: как у целевого объекта
Свойства:
- __new__(cls, obj[, callback])
- При обращении к атрибуту, если объект мёртв — ReferenceError
- Поддерживает арифметику, вызов, индексацию и т.д.

`generator`

Результат вызова функции с yield.

Атрибуты:
- __name__, __qualname__ — из функции
- gi_frame — объект frame (может быть None после завершения)
- gi_code — code функции
- gi_running — bool, выполняется ли сейчас
- gi_yieldfrom — None или подгенератор, если yield from
Методы:
- __next__() — продолжает выполнение до yield или StopIteration
- send(value) — передаёт значение в yield
- throw(type[, value[, traceback]]) — возбуждает исключение в генераторе
- close() — завершает генератор, вызывая GeneratorExit
Свойства:
- Реализует collections.abc.Iterator
- Не хэшируем
- После исчерпания — gi_frame = None, повторный __next__ → StopIteration

`coroutine`

Объект асинхронной функции (async def).

Атрибуты:
- __name__, __qualname__, __doc__
- cr_await — ожидаемый объект (None, если не в await)
- cr_frame, cr_code — текущий фрейм и код
- cr_running — bool
Методы:
- send(value)
- throw(type[, value[, traceback]])
- close()
Свойства:
- __await__() возвращает сам объект
- await coro → запускает выполнение до await или return
- После завершения — StopIteration (с value) или StopAsyncIteration; cr_frame = None

`async_generator`

Результат async def с yield.

Атрибуты:
- __name__, __qualname__
- ag_frame, ag_code, ag_running, ag_await
Методы:
- asend(value)
- athrow(type[, value[, traceback]])
- aclose()
- __aiter__() → сам объект
- __anext__() → awaitable, возвращает value или StopAsyncIteration
Свойства:
- Используется в async for
- Асинхронный аналог generator

`code`

Байт-код функции (доступен через func.__code__).

Атрибуты:
- co_argcount, co_posonlyargcount, co_kwonlyargcount
- co_nlocals, co_stacksize, co_flags
- co_code — bytes, байт-код
- co_consts — кортеж констант (None, int, str, code, ...)
- co_names — имена глобальных переменных
- co_varnames — имена локальных переменных
- co_filename, co_name, co_firstlineno
- co_lnotab — таблица сопоставления байт-код ↔ строки (устарела в 3.10+, заменена на co_lines())
- co_freevars, co_cellvars — имена замыканий
Методы:
- co_lines() — генератор (start, end, lineno) для отладки
- co_positions() — генератор (lineno, end_lineno, col_offset, end_col_offset)
Свойства:
- Хэшируем
- Конструируется через types.CodeType(...)

`frame`

Контекст выполнения (стек вызовов).

Атрибуты:
- f_back — предыдущий фрейм (None на вершине)
- f_code — code
- f_locals, f_globals, f_builtins — словари
- f_lasti — индекс текущей инструкции в co_code
- f_lineno — текущая строка
- f_trace — функция трассировки (sys.settrace)
- f_trace_lines, f_trace_opcodes — флаги трассировки
Свойства:
- Доступен через inspect.currentframe(), tb.tb_frame, gen.gi_frame
- Не рекомендуется к сохранению — содержит циклические ссылки
- f_locals может требовать f_locals.update() при изменении извне

`traceback`

Цепочка трассировок исключения.

Атрибуты:
- tb_next — следующий traceback (None, если конец)
- tb_frame — frame
- tb_lasti, tb_lineno — как в frame
Свойства:
- Хэшируем
- Сериализуется через traceback.print_tb(), traceback.format_tb()
- Используется в sys.exc_info()[2]

`getset_descriptor`

Дескриптор, вызываемый при доступе к атрибуту (__get__, __set__ реализованы в C).

Атрибуты:
- __name__, __doc__
Свойства:
- Используется в datetime.datetime.year, array.array.typecode и др.
- __get__(obj, type) → значение
- __set__(obj, value) → присваивание (если есть)
- __delete__ — опционален

`method_descriptor`, `wrapper_descriptor`

Объекты методов, реализованные в C (например, dict.get, list.append).

Атрибуты:
- __name__, __doc__, __qualname__, __objclass__
Свойства:
- При доступе через экземпляр → builtin_method_or_method_descriptor с __self__ = obj
- При доступе через класс → method_descriptor
- __get__(obj, type) возвращает привязанный метод
- Документация содержит сигнатуру в __text_signature__ (например, ($self, key, default=None, /))

1.3 Встроенные функции

(Выборочно — наиболее употребительные. Полный список: 70+)

`abs(x)`

Возвращает абсолютное значение:

int, float, complex → |x|
Объект с __abs__() → результат вызова
Сигнатура: abs(x: SupportsAbs[T]) -> T

`aiter(async_iterable)`

Возвращает асинхронный итератор через async_iterable.__aiter__()

`all(iterable)`

Возвращает True, если все элементы истинны или итерируемое пусто.

`any(iterable)`

Возвращает True, если хотя бы один элемент истинен.

`ascii(object)`

Возвращает repr(object), экранируя непечатаемые ASCII символы как \x, \u, \U.

`bin(x)`

Возвращает двоичную строку '0b...' для целого x.

`bool(x=False)`

Преобразует x в bool:

False: None, False, 0, 0.0, 0j, '', (), [], {}, set(), range(0)
True: всё остальное
Объект с __bool__() → результат вызова; иначе __len__() → len != 0

`breakpoint(*args, **kws)`

Вызывает sys.breakpointhook(*args, **kws) (по умолчанию — pdb.set_trace())

`bytearray(source=b'', encoding=None, errors='strict')`

Создаёт изменяемый байтовый массив.

source: int, str (с encoding), bytes, Iterable[int], buffer

`bytes(source=b'', encoding=None, errors='strict')`

Создаёт неизменяемый байтовый объект.

`callable(object)`

Возвращает True, если объект вызываем (__call__ существует и не None).

`chr(i)`

Возвращает строку длины 1 с Unicode-символом с кодом i (0 ≤ i ≤ 0x10FFFF)

`classmethod(func)`

Преобразует функцию в метод класса.

`compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)`

Компилирует source (строка/AST) в code.

mode: 'exec', 'eval', 'single'
optimize: -1 (текущий), 0, 1, 2

`complex(real=0, imag=0)`

Создаёт комплексное число.

real: int, float, complex, str (например, '3+4j')
imag: int, float

`delattr(object, name)`

Удаляет атрибут name из object (del object.name).

`dict(iterable=(), **kwargs)`

Создаёт словарь.

iterable: итератор пар (key, value)
**kwargs — именованные аргументы

`dir([object])`

Возвращает список имён в локальном пространстве имён (если object не указан) или атрибутов объекта.

Вызывает object.__dir__() при наличии
Иначе: sorted(object.__dict__.keys() + базовые атрибуты)

`divmod(a, b)`

Возвращает (a // b, a % b) для чисел; вызывает a.__divmod__(b).

`enumerate(iterable, start=0)`

Возвращает итератор кортежей (index, value).

`eval(expression, globals=None, locals=None)`

Выполняет строку как выражение.

globals, locals — словари; globals должен содержать __builtins__, если задан
Рекомендуется избегать при ненадёжном expression

`exec(object, globals=None, locals=None)`

Выполняет строку как оператор.

object: str, bytes, code
Возвращает None

`filter(function, iterable)`

Возвращает итератор, для которого function(item) истинно.

function = None → фильтрация на истинность

`float(x=0.0)`

Преобразует x в float.

x: int, float, str, bytes, объект с __float__()
float('inf'), float('-inf'), float('nan')

`format(value, format_spec='')`

Вызывает value.__format__(format_spec).

`frozenset(iterable=())`

Создаёт неизменяемое множество.

`getattr(object, name[, default])`

Возвращает object.name.

Если атрибут отсутствует и указан default — возвращает default
Иначе — AttributeError

`globals()`

Возвращает словарь глобальных переменных текущего модуля.

`hasattr(object, name)`

Возвращает True, если object имеет атрибут name.

`hash(object)`

Возвращает хэш объекта.

Объект должен быть хэшируем (__hash__ не None)
Хэш int равен значению (кроме -1, который отображается в -2)
Хэш str, bytes, tuple зависит от содержимого
Хэш None, True, False — фиксированные

`help([object])`

Запускает интерактивную справку.

help(str) → документация по str
Вызывает pydoc.help()

`hex(x)`

Возвращает шестнадцатеричную строку '0x...' для целого x.

`id(object)`

Возвращает уникальный идентификатор объекта (адрес в памяти в CPython).

`input([prompt])`

Читает строку из sys.stdin.

Выводит prompt, если задан
Возвращает str

`int(x=0, base=10)`

Преобразует x в целое.

x: int, float, str, bytes, Fraction, Decimal
base: 0 (авто) или 2–36
int('10', 2) == 2

`isinstance(object, classinfo)`

Проверяет, является ли object экземпляром classinfo.

classinfo: класс, кортеж классов, GenericAlias (например, list[int])
Учитывает наследование и __instancecheck__

`issubclass(class, classinfo)`

Проверяет, является ли class подклассом classinfo.

`iter(object[, sentinel])`

Возвращает итератор.

object с __iter__() → object.__iter__()
object с __getitem__() → итератор по индексам
sentinel: если задан — вызывает object() до возврата sentinel

`len(s)`

Возвращает длину: s.__len__()

`list(iterable=())`

Создаёт список.

`locals()`

Возвращает словарь локальных переменных текущего фрейма.

Изменения в словаре могут не влиять на фрейм (зависит от реализации)

`map(function, iterable, ...)`

Применяет function к элементам итерируемых.

Для нескольких итерируемых: function(item1, item2, ...)

`max(iterable, *[, key, default])`

Возвращает наибольший элемент.

key: функция для извлечения ключа сравнения
default: значение при пустом итерируемом

`min(...)`

Аналогично max, наименьший элемент.

`next(iterator[, default])`

Получает следующий элемент.

StopIteration, если итератор исчерпан и default не указан

`object()`

Создаёт базовый объект.

Единственный экземпляр без данных
Все объекты наследуют от object

`oct(x)`

Возвращает восьмеричную строку '0o...' для целого x.

`open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)`

Открывает файл.

mode: 'r', 'w', 'a', 'b', 't', '+'
buffering: -1 (по умолчанию), 0 (нет), 1 (строковый), >1 (размер)
encoding: 'utf-8', 'cp1251', и т.д.
errors: 'strict', 'ignore', 'replace', 'backslashreplace'
newline: управляет обработкой \n, \r\n, \r
Возвращает TextIOWrapper, BufferedWriter, FileIO в зависимости от режима

`ord(c)`

Возвращает код Unicode символа c (строка длины 1).

`pow(base, exp[, mod])`

Вычисляет base ** exp % mod, если mod задан, иначе base ** exp.

Поддерживает отрицательные степени при mod (только для целых, base и mod взаимно просты)

`print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)`

Выводит объекты.

sep — разделитель
end — завершающая строка
file — объект с write()
flush=True — сброс буфера немедленно

`property(fget=None, fset=None, fdel=None, doc=None)`

Создаёт дескриптор свойства.

`range(stop)`, `range(start, stop[, step])`

Создаёт арифметическую прогрессию.

Все параметры — целые
step != 0

`repr(object)`

Возвращает object.__repr__() — официальное строковое представление.

`reversed(seq)`

Возвращает итератор в обратном порядке.

seq должен иметь __reversed__() или поддерживать __len__ и __getitem__

`round(number[, ndigits])`

Округляет до ndigits знаков.

При .5 — к ближайшему чётному (round(2.5) == 2, round(3.5) == 4)
ndigits=None или не указан — округление до целого

`set(iterable=())`

Создаёт множество.

`setattr(object, name, value)`

Устанавливает object.name = value.

`slice(stop)`, `slice(start, stop[, step])`

Создаёт объект среза.

`sorted(iterable, *, key=None, reverse=False)`

Возвращает новый отсортированный список.

key: функция сортировки
reverse: порядок сортировки

`staticmethod(func)`

Преобразует функцию в статический метод.

`str(object='')`, `str(object=b'', encoding='utf-8', errors='strict')`

Создаёт строку.

Для bytes: декодирует через encoding

`sum(iterable, /, start=0)`

Суммирует элементы.

start — начальное значение
Не поддерживает строковые iterable (''.join вместо sum)

`super([type[, object-or-type]])`

Возвращает прокси для поиска атрибутов в базовых классах.

В методе: super() → super(текущий_класс, self)
Поддерживает MRO

`tuple(iterable=())`

Создаёт кортеж.

`type(object)`

Возвращает класс объекта.

`type(name, bases, dict, **kwargs)`

Создаёт новый класс.

`vars([object])`

Возвращает object.__dict__; без аргумента — locals().

`zip(*iterables, strict=False)`

Объединяет итерируемые поэлементно.

strict=False (по умолчанию): останавливается по короткому
strict=True: ValueError, если длины различаются

`import(name, globals=None, locals=None, fromlist=(), level=0)`

Низкоуровневый импорт модуля.

Используется в import ..., не рекомендуется напрямую
level: 0 (абсолютный), >0 (относительный)

1.4 Встроенные исключения

Иерархия (сокращённая, ключевые узлы):

BaseException
 ├── BaseExceptionGroup
 ├── GeneratorExit
 ├── KeyboardInterrupt
 ├── SystemExit
 └── Exception
      ├── ArithmeticError
      │    ├── FloatingPointError
      │    ├── OverflowError
      │    └── ZeroDivisionError
      ├── AssertionError
      ├── AttributeError
      ├── BufferError
      ├── EOFError
      ├── ImportError
      │    └── ModuleNotFoundError
      ├── LookupError
      │    ├── IndexError
      │    └── KeyError
      ├── MemoryError
      ├── NameError
      │    └── UnboundLocalError
      ├── OSError
      │    ├── BlockingIOError
      │    ├── ChildProcessError
      │    ├── ConnectionError
      │    │    ├── ...
      │    ├── FileExistsError
      │    ├── FileNotFoundError
      │    ├── InterruptedError
      │    ├── IsADirectoryError
      │    ├── NotADirectoryError
      │    ├── PermissionError
      │    ├── ProcessLookupError
      │    └── TimeoutError
      ├── ReferenceError
      ├── RuntimeError
      │    ├── NotImplementedError
      │    └── RecursionError
      ├── StopIteration
      ├── StopAsyncIteration
      ├── SyntaxError
      │    └── IndentationError
      │         └── TabError
      ├── SystemError
      ├── TypeError
      ├── ValueError
      │    └── UnicodeError
      │         ├── UnicodeDecodeError
      │         ├── UnicodeEncodeError
      │         └── UnicodeTranslateError
      └── Warning
           ├── ...

Каждый класс исключения имеет:

args — кортеж аргументов, переданных в конструктор
__cause__ — исключение, вызвавшее текущее (raise ... from ...)
__context__ — исключение, при обработке которого возникло текущее
__traceback__ — объект traceback
with_traceback(tb) — устанавливает __traceback__, возвращает исключение

📘 Часть 2. Стандартная библиотека Python

Версия: CPython 3.12. Покрытие — 130+ наиболее употребительных модулей.

2.1 `abc` — Abstract Base Classes

Предназначен для определения абстрактных базовых классов и интерфейсов.

`ABC`

Базовый класс для абстрактных классов. Наследуется от metaclass=ABCMeta.

`ABCMeta`

Метакласс, проверяющий реализацию абстрактных методов при создании подкласса.

`abstractmethod(func)`

Декоратор: помечает метод как обязательный к переопределению.

Должен применяться до других декораторов (@property, @classmethod).
Если не переопределён — TypeError при создании экземпляра.

`abstractproperty`, `abstractclassmethod`, `abstractstaticmethod`

Устаревшие алиасы. Рекомендуется использовать комбинацию:

@property
@abstractmethod
def x(self): ...

`ABC.register(cls)`

Вручную регистрирует cls как виртуальный подкласс. Не проверяет реализацию.

`issubclass(cls, ABC)`, `isinstance(obj, ABC)`

Работают с виртуальными подклассами и проверяют реализацию интерфейса.

2.2 `argparse` — Парсинг аргументов командной строки

`ArgumentParser(prog=None, usage=None, description=None, epilog=None, parents=[], formatter_class=argparse.HelpFormatter, prefix_chars='-', fromfile_prefix_chars=None, argument_default=None, conflict_handler='error', add_help=True, allow_abbrev=True, exit_on_error=True)`

Основной класс.

parents — список других ArgumentParser, чьи аргументы наследуются
formatter_class — argparse.RawDescriptionHelpFormatter, argparse.ArgumentDefaultsHelpFormatter и др.
allow_abbrev — разрешить сокращённые имена (--ver → --verbose), по умолчанию True
exit_on_error — при ошибке вызывать sys.exit(), иначе — ArgumentError

`add_argument(name_or_flags..., action='store', nargs=None, const=None, default=None, type=None, choices=None, required=False, help=None, metavar=None, dest=None)`

Добавляет параметр.

action:
- 'store', 'store_const', 'store_true', 'store_false',
- 'append', 'append_const', 'count',
- 'help', 'version'
nargs: N, '?', '*', '+', argparse.REMAINDER
type: int, float, str, pathlib.Path, argparse.FileType('r'), пользовательские функции
choices: итерируемый, проверка in choices
default: значение по умолчанию (применяется, если аргумент не указан)
required: только для не-флагов (например, позиционных)
dest: имя атрибута в Namespace
metavar: имя в справке (--input FILE, а не --input INPUT)

`parse_args(args=None, namespace=None)`

Возвращает Namespace.

args=None → sys.argv[1:]
namespace=MyClass() → атрибуты присваиваются объекту

`parse_known_args(args=None, namespace=None)`

Возвращает (namespace, unknown_args) — для передачи неизвестных аргументов дальше.

`FileType(mode='r', bufsize=-1, encoding=None, errors=None)`

Тип для автоматического открытия файлов.

Используется как type=argparse.FileType('w')
Файлы закрываются при уничтожении Namespace

2.3 `asyncio` — Асинхронное программирование

Ядро асинхронного выполнения.

`run(coro, *, debug=None, loop_factory=None)`

Запускает корутину и возвращает результат.

Блокирует до завершения
Создаёт и закрывает EventLoop автоматически
loop_factory — вызываемый, возвращающий AbstractEventLoop

`create_task(coro, *, name=None, context=None)`

Создаёт Task в текущем цикле.

context — contextvars.Context, по умолчанию copy_context()

`gather(*aws, return_exceptions=False)`

Запускает awaitables параллельно.

Возвращает список результатов в порядке аргументов
return_exceptions=True → исключения возвращаются как значения
Отмена gather() отменяет все задачи

`wait(aws, *, timeout=None, return_when=ALL_COMPLETED)`

Ждёт завершения awaitables.

Возвращает (done: set, pending: set)
return_when: FIRST_COMPLETED, FIRST_EXCEPTION, ALL_COMPLETED

`as_completed(aws, *, timeout=None)`

Асинхронный итератор: итерирует по мере завершения.

`EventLoop`

Основной цикл событий.

run_until_complete(future)
run_forever(), stop()
call_soon(callback, *args, context=None)
call_later(delay, callback, *args, context=None)
call_at(when, callback, *args, context=None)
time() — монотонное время в секундах
create_future()
create_task(coro)
run_in_executor(executor, func, *args) — запускает в потоке/процессе
add_reader(fd, callback, *args) / remove_reader(fd)
add_writer(fd, callback, *args) / remove_writer(fd)

Потокобезопасные методы:

call_soon_threadsafe(callback, *args, context=None)
loop.call_soon_threadsafe(...) — единственный способ запланировать из другого потока

`Task(coro, *, loop=None, name=None, context=None)`

Обёртка над корутиной.

done(), cancelled(), result(), exception(), add_done_callback(fn), remove_done_callback(fn)
cancel() — запрашивает отмену; cancellation() не гарантирует немедленное завершение
get_name(), set_name(name)

`Future`

Низкоуровневый примитив.

set_result(value), set_exception(exc)
result(), exception() блокируют, если не готовы
Поддерживает await

`Lock`, `Event`, `Condition`, `Semaphore`, `Barrier`

Асинхронные аналоги threading.

Используют await acquire(), release()
Event.wait(), Event.set(), Event.clear()
Condition.wait(), Condition.notify(), Condition.notify_all()
Все примитивы привязаны к текущему циклу

`Stream`

open_connection(host, port, ...) → (reader: StreamReader, writer: StreamWriter)
start_server(client_connected_cb, host, port, ...)
StreamReader.read(n=-1), readline(), readuntil(), readexactly()
StreamWriter.write(data), drain(), close(), wait_closed()
drain() — await при буфере > 64 КБ (предотвращает OOM)

`subprocess`

create_subprocess_exec(*args, stdin=None, stdout=None, stderr=None, ...)
Возвращает Process с атрибутами stdin, stdout, stderr (StreamWriter/StreamReader)
wait(), communicate(), terminate(), kill()

`run_in_executor(executor, func, *args)`

Запускает func(*args) в concurrent.futures.Executor.

По умолчанию — ThreadPoolExecutor
Для CPU-bound — ProcessPoolExecutor

2.4 `collections` — Дополнительные типы данных

`namedtuple(typename, field_names, *, rename=False, defaults=None, module=None)`

Фабрика классов: неизменяемый кортеж с именованными полями.

rename=True — переименовывает некорректные имена (class, 1 → _1)
defaults — кортеж значений по умолчанию (справа)
Экземпляр имеет __slots__ = (), меньше памяти, чем dict
Поддерживает pickle, __eq__, __repr__, ._asdict(), ._replace(), ._fields, ._field_defaults

`deque(iterable=(), maxlen=None)`

Двусторонняя очередь.

append(x), appendleft(x), pop(), popleft() — O(1)
extend(iterable), extendleft(iterable)
rotate(n=1) — сдвиг на n (отрицательный — влево)
maxlen — автоматически popleft() при переполнении
copy(), __copy__(), __deepcopy__()
Потокобезопасен для операций с одной стороны (но не атомарен при maxlen)

`ChainMap(*maps)`

Цепочка словарей для поиска.

maps — список отображений ([first, second, ...])
new_child(m=None) → ChainMap(m, *maps)
parents → ChainMap(*maps[1:])
Изменения ведутся в первом словаре

`Counter(iterable_or_mapping=(), **kwds)`

Счётчик хэшируемых объектов.

update(iterable_or_mapping) — инкремент
subtract(iterable_or_mapping) — декремент
most_common(n=None) — сортировка по убыванию
elements() — итератор, повторяющий элементы по счётчику
+, -, &, | — арифметика (неотрицательные значения)

`OrderedDict()`

Устарел с Python 3.7 (обычный dict сохраняет порядок).

move_to_end(key, last=True)
popitem(last=True)

`defaultdict(default_factory=None)`

Словарь с автоматической инициализацией отсутствующих ключей.

default_factory: list, set, int, lambda: 0, и т.д.
__missing__(key) вызывает default_factory(), сохраняет и возвращает

`UserDict`, `UserList`, `UserString`

Обёртки для наследования с переопределением data.

UserDict → self.data: dict
UserList → self.data: list
UserString → self.data: str
Рекомендованы вместо прямого наследования от dict/list/str

2.5 `contextlib` — Управление контекстами

`contextmanager(func)`

Декоратор: превращает генератор в менеджер контекста.

@contextmanager
def ctx():
    setup()
    try:
        yield resource
    finally:
        cleanup()

`asynccontextmanager(func)`

Асинхронный аналог.

`ContextDecorator`

Базовый класс: позволяет использовать объект и как менеджер контекста, и как декоратор.

`nullcontext(enter_result=None)`

Пустой контекст: enter_result возвращается из __enter__().

`ExitStack()`

Динамическое управление несколькими контекстами.

enter_context(cm)
push(exit) — функция exit(exc_type, exc, tb)
callback(callback, *args, **kwds)
close() — вызывает все exit в обратном порядке
__enter__ возвращает self

`AsyncExitStack()`

Асинхронный аналог.

2.6 `dataclasses` — Классы данных

`@dataclass(*, init=True, repr=True, eq=True, order=False, unsafe_hash=False, frozen=False, match_args=True, kw_only=False, slots=False, weakref_slot=False)`

Декоратор для автоматической генерации методов.

init: генерирует __init__(self, a, b=...)
repr: __repr__() в виде ClassName(a=1, b=2)
eq: __eq__() по полям
order: генерирует __lt__, __le__, __gt__, __ge__
frozen=True: имитирует неизменяемость (__setattr__ → FrozenInstanceError)
kw_only=True: все поля — ключевые (начиная с Python 3.10)
slots=True: создаёт __slots__, снижает потребление памяти
weakref_slot=True: добавляет __weakref__ в __slots__

`field(*, default=MISSING, default_factory=MISSING, init=True, repr=True, hash=None, compare=True, metadata=None, kw_only=MISSING)`

Настройка отдельного поля.

default_factory=lambda: [] — для мутабельных значений
hash=False — исключить из __hash__()
compare=False — исключить из сравнения
metadata — произвольный Mapping (доступен через fields(cls)[i].metadata)

`asdict(obj, *, dict_factory=dict)`

Рекурсивно преобразует в dict.

dataclass → dict, tuple → list, set → list
Циклические ссылки → RecursionError

`astuple(obj, *, tuple_factory=tuple)`

Аналогично, в tuple.

`is_dataclass(obj)`

Проверяет, является ли obj классом или экземпляром dataclass.

`fields(cls)`

Возвращает кортеж Field объектов.

`replace(obj, **changes)`

Возвращает новый экземпляр с изменёнными полями (только для frozen=False или __post_init__ корректен).

2.7 `datetime` — Дата и время

`date(year, month, day)`

Атрибуты: year, month, day
Методы:
- today(), fromtimestamp(timestamp), fromordinal(ordinal)
- replace(year, month, day)
- timetuple() → time.struct_time
- toordinal()
- weekday() (0=понедельник), isoweekday() (1=понедельник)
- isocalendar() → (year, week, weekday)
- isoformat(), __str__() → YYYY-MM-DD
- ctime(), strftime(format)

`time(hour=0, minute=0, second=0, microsecond=0, tzinfo=None, fold=0)`

fold — для разрешения неоднозначности при переходе на зимнее время (0 или 1)
Методы: replace(), isoformat(), strftime(), utcoffset(), dst(), tzname()

`datetime(year, month, day, hour=0, minute=0, second=0, microsecond=0, tzinfo=None, *, fold=0)`

Наследует методы от date и time
now(tz=None), utcnow(), fromtimestamp(timestamp, tz=None), utcfromtimestamp(timestamp)
strptime(date_string, format)
combine(date, time, tzinfo=None)
timestamp() — возвращает POSIX timestamp (секунды с 1970-01-01 UTC)

`timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0)`

Только days, seconds, microseconds хранятся; остальное конвертируется
Поддерживает +, -, * (int/float), /, //, %, divmod
total_seconds() — общее количество секунд (float)

`timezone(offset, name=None)`

offset: timedelta, -14:00 ≤ offset ≤ +14:00
utc = timezone.utc

`tzinfo`

Абстрактный базовый класс.

utcoffset(dt), dst(dt), tzname(dt)
fromutc(dt) — для обратного преобразования

`datetime.astimezone(tz=None)`

Преобразует в указанную зону.

tz=None → локальная зона (tzlocal())
Требует, чтобы исходный datetime был aware (либо tzinfo, либо вызван replace(tzinfo=...))

2.8 `functools` — Функциональные примитивы

`cache(user_function)`

Декоратор: кэширует вызовы (LRU без ограничения размера).

Аналог lru_cache(maxsize=None)
Потокобезопасен, использует dict

`lru_cache(maxsize=128, typed=False)`

Кэш с ограничением размера (Least Recently Used).

maxsize=None — без ограничения
typed=True — 3 и 3.0 кэшируются отдельно
Методы экземпляра: cache_info(), cache_clear()

`partial(func, /, *args, **keywords)`

Частичное применение.

partial(func, a, b=2)(c, d=3) → func(a, c, b=2, d=3)
Атрибуты: func, args, keywords

`partialmethod(func, /, *args, **keywords)`

Аналог partial, но для методов (работает в классе).

`singledispatch(func)`

Диспетчеризация по типу первого аргумента.

@func.register(cls) — регистрирует реализацию для cls
Поддерживает наследование
@func.register без аргумента — регистрация по аннотации func.__annotations__['obj']

`singledispatchmethod(func)`

Вариант для методов.

`wraps(wrapped, assigned=WRAPPER_ASSIGNMENTS, updated=WRAPPER_UPDATES)`

Декоратор: копирует метаданные (__name__, __doc__, __annotations__) из wrapped в обёртку.

`total_ordering(cls)`

Декоратор: добавляет недостающие методы сравнения, если реализованы __eq__ и один из __lt__, __le__, __gt__, __ge__.

`cmp_to_key(mycmp)`

Преобразует функцию сравнения mycmp(a, b) → -1/0/1 в ключ для sorted(), min(), max().

2.9 `itertools` — Итераторы для эффективных циклов

`count(start=0, step=1)`

Бесконечный счётчик. next() → start, start+step, ...

`cycle(iterable)`

Циклически повторяет iterable.

`repeat(object, times=None)`

Повторяет объект. times=None — бесконечно.

`chain(*iterables)`

Объединяет итерируемые в один поток.

`compress(data, selectors)`

Возвращает элементы data, где selectors истинны.

`dropwhile(predicate, iterable)`

Пропускает элементы, пока predicate истинен, затем возвращает остальное.

`takewhile(predicate, iterable)`

Возвращает элементы, пока predicate истинен.

`filterfalse(predicate, iterable)`

Обратное filter: возвращает, где predicate ложен.

`groupby(iterable, key=None)`

Группирует последовательные одинаковые элементы по key(item).

Требует предварительной сортировки, если нужна полная группировка

`islice(iterable, start, stop[, step])`

Срез итератора без полной материализации.

`starmap(function, iterable)`

function(*args) для каждого args в iterable.

`tee(iterable, n=2)`

Возвращает n независимых итераторов из одного.

Буферизация происходит по мере отставания итераторов
Не рекомендуется при большом разрыве

`zip_longest(*iterables, fillvalue=None)`

Как zip, но до самого длинного; недостающие — fillvalue.

`product(*iterables, repeat=1)`

Декартово произведение.

product('AB', 'xy') → ('A','x'), ('A','y'), ('B','x'), ('B','y')

`permutations(iterable, r=None)`

Все перестановки длины r (r=None → len(iterable)).

`combinations(iterable, r)`

Все сочетания без повторений.

`combinations_with_replacement(iterable, r)`

Сочетания с повторениями.

2.10 `json` — JSON-сериализация

`dumps(obj, *, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, default=None, sort_keys=False, **kw)`

Сериализует в строку.

ensure_ascii=True — все не-ASCII экранируются (\uXXXX)
indent=2 или ' ' — красивый вывод
separators=(',', ':') — по умолчанию; (',', ': ') для читаемости
default — функция для несериализуемых объектов
sort_keys=True — для детерминированного вывода

`dump(obj, fp, ...)`

Записывает в файлоподобный объект fp.write().

`loads(s, *, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, **kw)`

Десериализует строку.

object_hook=dict → вызывается для каждого dict: object_hook(d)
object_pairs_hook — имеет приоритет; принимает список пар [('a',1), ...]
parse_float=float, parse_int=int, parse_constant для NaN, Infinity

`load(fp, ...)`

Читает из fp.read().

`JSONEncoder`, `JSONDecoder`

Базовые классы для кастомизации.

Переопределяется JSONEncoder.default(self, obj)
JSONDecoder.object_hook, JSONDecoder.parse_float, и т.д.

2.11 `logging` — Журналирование

`getLogger(name=None)`

Возвращает или создаёт логгер с именем name.

name=None или '' → корневой логгер (logging.root)
Иерархия через точки: getLogger('a.b') — дочерний для getLogger('a')
Наследует уровень и обработчики от родителя, если не переопределены

`Logger`

Основной класс.

Уровни (числовые значения):
- CRITICAL = 50
- ERROR = 40
- WARNING = 30
- INFO = 20
- DEBUG = 10
- NOTSET = 0
Методы записи:
- debug(msg, *args, **kwargs)
- info(...), warning(...), error(...), critical(...)
- log(level, msg, *args, **kwargs)
- exception(msg, *args, exc_info=True, **kwargs) — логирует текущее исключение
Дополнительно:
- setLevel(level)
- addHandler(hdlr), removeHandler(hdlr)
- isEnabledFor(level)
- findCaller(stack_info=False, stacklevel=1)
Поведение по умолчанию: корневой логгер имеет WARNING и StreamHandler(sys.stderr)

`Handler`

Базовый класс обработчиков.
Подклассы:

StreamHandler(stream=None) → sys.stderr по умолчанию
FileHandler(filename, mode='a', encoding=None, delay=False)
RotatingFileHandler(filename, mode='a', maxBytes=0, backupCount=0, encoding=None, delay=False)
- При maxBytes > 0 — переключает на filename.1, filename.2, ...
TimedRotatingFileHandler(filename, when='h', interval=1, backupCount=0, ...)
- when: 'S', 'M', 'H', 'D', 'W0'–'W6', 'midnight'
SocketHandler(host, port)
HTTPHandler(host, url, method='GET')
BufferingHandler(capacity) — буферизует до capacity записей
MemoryHandler(capacity, flushLevel=ERROR, target=None) — сбрасывает при flushLevel

`Formatter(fmt=None, datefmt=None, style='%', validate=True, *, defaults=None)`

Форматирует сообщения.

style='%': '%(levelname)s:%(name)s:%(message)s'
style='{': '{levelname}:{name}:{message}'
style='$': '$levelname:$name:$message'
Стандартные поля:
- name, levelno, levelname, pathname, filename, module, lineno, funcName,
- created (timestamp), asctime, msecs, relativeCreated,
- thread, threadName, process, processName,
- message
datefmt — как в time.strftime()
defaults — словарь дополнительных полей по умолчанию

`Filter`

Фильтрует записи.

filter(record) → 0 (отклонить) / 1 (пропустить)
name — допускает только логгеры, начинающиеся с name

`LogRecord`

Представляет одну запись.

Поля заполняются автоматически при вызове logger.info(...)
Доступны через record.levelname, record.message, и т.д.
getMessage() — возвращает msg % args

`basicConfig(**kwargs)`

Настройка корневого логгера один раз (игнорируется при повторном вызове, если уже настроен).
Параметры:

level
filename, filemode='a'
format, datefmt, style
handlers — список обработчиков (если задан, игнорирует filename, filemode, stream)
force=False — перенастроить, даже если уже настроен (Python ≥ 3.8)
encoding=None, errors=None

Потокобезопасность

Logger, Handler, Formatter — потокобезопасны
Используют внутренние блокировки (threading.RLock)
Не гарантируется порядок записей при высокой нагрузке

Стандартные обработчики для продвинутого использования

QueueHandler(queue) + QueueListener(handler, ...) — асинхронная запись
NullHandler() — заглушка для библиотек (не выводит, не создаёт предупреждения)

2.12 `multiprocessing` — Параллелизм на основе процессов

`Process(target=None, args=(), kwargs={}, *, name=None, daemon=None)`

Аналог threading.Thread, но запускает новый процесс.

start(), join([timeout]), is_alive(), terminate(), kill(), close()
pid, exitcode, name, daemon
close() освобождает ресурсы (Python ≥ 3.7)

`Queue([maxsize])`

Межпроцессная очередь (на основе Pipe + фоновый поток).

put(obj[, block[, timeout]]), get([block[, timeout]])
qsize(), empty(), full() — ненадёжны в многопроцессной среде
Не поддерживает pickle-небезопасные объекты

`Pipe([duplex])`

Возвращает (conn1, conn2) — соединение «точка-точка».

duplex=True (по умолчанию) — двунаправленное
send(obj), recv()
poll([timeout]), close(), fileno()
Поддерживает передачу файловых дескрипторов (Unix)

`Manager()`

Создаёт прокси-объекты для совместного использования:

list(), dict(), Namespace(), Lock(), RLock(), Semaphore(), BoundedSemaphore(), Condition(), Event(), Barrier(), Queue(), Value(), Array()
Серверный процесс управляет состоянием
Медленнее, чем multiprocessing.Queue, но гибче

`Value(typecode_or_type, *args, lock=True)`

Разделяемая память для одного значения.

typecode_or_type: 'i', 'd', ctypes.c_int, и т.д.
lock=False — отключает синхронизацию (опасно)
Доступ через .value

`Array(typecode_or_type, size_or_initializer, *, lock=True)`

Разделяемый массив.

Доступ через arr[i], arr[:]
Поддерживает срезы и присваивание

`Pool([processes[, initializer[, initargs[, maxtasksperchild[, context]]]]])`

Пул рабочих процессов.

apply(func, args=..., kwds=...) — синхронно
apply_async(func, args=..., kwds=..., callback=None, error_callback=None)
map(func, iterable[, chunksize]), map_async(...)
starmap(func, iterable[, chunksize]), starmap_async(...)
imap(func, iterable[, chunksize]) → итератор (ленивый)
imap_unordered(...)
close(), terminate(), join()
maxtasksperchild — перезапуск процесса после N задач (предотвращает утечки)

`get_context(method=None)`

Возвращает контекст запуска:

'fork' (Unix, по умолчанию) — копирует процесс
'spawn' (Windows, также на Unix) — запускает новый интерпретатор
'forkserver' — отдельный сервер форкает процессы
Важно для совместимости с CUDA, GUI, и т.д.

`current_process()`

Возвращает объект текущего процесса (Process).

pid, name, authkey, exitcode, daemon

`set_start_method(method, force=False)`

Устанавливает метод запуска глобально. Вызывать до создания любых объектов.

2.13 `os` — Интерфейс к операционной системе

Пути и файлы

sep, altsep, pathsep, linesep, curdir, pardir, defpath, devnull — константы
name — 'posix', 'nt', 'java'
path — объект с методами:
- exists(path), isfile(path), isdir(path), islink(path)
- getsize(path), getmtime(path), getatime(path), getctime(path)
- join(a, *p), split(path), splitext(path), dirname(path), basename(path)
- normpath(path), abspath(path), realpath(path), relpath(path, start=curdir)
- expanduser(path), expandvars(path)
- commonprefix(list), commonpath(paths)

Рабочая директория

getcwd(), chdir(path), mkdir(path, mode=0o777), makedirs(name, mode=0o777, exist_ok=False)
rmdir(path), removedirs(name)
listdir(path='.'), walk(top, topdown=True, onerror=None, followlinks=False)

Процессы и окружение

getpid(), getppid(), getuid(), getgid(), geteuid(), getegid()
environ — мутабельный словарь переменных окружения
getenv(key, default=None), putenv(key, value), unsetenv(key)
system(command), popen(cmd, mode='r', buffering=-1) — устаревшее, использовать subprocess

Управление файлами

open(path, flags, mode=0o777, *, dir_fd=None) — низкоуровневое (os.O_RDONLY, os.O_WRONLY | os.O_CREAT, и т.д.)
close(fd), read(fd, n), write(fd, str), lseek(fd, pos, how)
fstat(fd), stat(path), lstat(path) → объект os.stat_result
chmod(path, mode), chown(path, uid, gid), utime(path, times=None, *, ns=None)
link(src, dst), symlink(src, dst), readlink(path), unlink(path), rename(src, dst), replace(src, dst)

Сигналы (Unix)

kill(pid, sig), getpgid(pid), setpgid(pid, pgid)
killpg(pgid, sig)

Прочее

urandom(n) — криптостойкий генератор (/dev/urandom или CryptGenRandom)
ctermid() — путь к управляющему терминалу
ttyname(fd) — имя терминала по дескриптору
getloadavg() — загрузка системы (Unix)

Потокобезопасность

Большинство вызовов — обёртки над системными вызовами, атомарны
environ — не потокобезопасен в CPython < 3.4; с 3.4+ — потокобезопасен

2.14 `pathlib` — Объектно-ориентированный интерфейс к путям

`PurePath(*pathsegments)`

Чисто вычислительный, без доступа к ФС.

PurePosixPath, PureWindowsPath — platform-specific
Операторы: / (конкатенация), // (аналогично /), in (проверка подпути)
Свойства:
- drive, root, anchor, parents, parent, name, stem, suffix, suffixes
Методы:
- as_posix(), as_uri(), is_absolute(), is_relative_to(other), joinpath(*other),
- match(pattern), relative_to(*other), with_name(name), with_stem(stem), with_suffix(suffix)

`Path(*pathsegments)`

Наследует от PurePath, добавляет ФС-операции.

cwd(), home() — классовые методы
ФС-методы:
- stat(), lstat(), owner(), group()
- chmod(mode), lchmod(mode), utime(times=None, ns=None)
- exists(), is_dir(), is_file(), is_symlink(), is_block_device(), is_char_device(), is_fifo(), is_socket()
- resolve(strict=False), absolute()
- glob(pattern), rglob(pattern)
- open(mode='r', buffering=-1, encoding=None, errors=None, newline=None)
- read_text(encoding=None, errors=None), write_text(data, encoding=None, errors=None)
- read_bytes(), write_bytes(data)
- mkdir(mode=0o777, parents=False, exist_ok=False)
- touch(mode=0o666, exist_ok=True)
- rename(target), replace(target), unlink(missing_ok=False)
- rmdir(), iterdir(), walk(top_down=True, on_error=None, follow_symlinks=False)

Совместимость

os.PathLike — протокол: __fspath__()
Все функции os, shutil, open принимают Path

2.15 `re` — Регулярные выражения

Общие параметры

Все функции принимают pattern (строка или скомпилированный Pattern)
Флаги (flags):
- re.IGNORECASE (re.I)
- re.MULTILINE (re.M)
- re.DOTALL (re.S)
- re.UNICODE (re.U, по умолчанию в Python 3)
- re.ASCII (re.A) — ограничивает \w, \d, \s ASCII
- re.VERBOSE (re.X) — игнорирует пробелы и комментарии в шаблоне

Компиляция

compile(pattern, flags=0) → re.Pattern
- Атрибуты: pattern, flags
- Методы: match(), fullmatch(), search(), findall(), finditer(), split(), sub(), subn()

Поиск и сопоставление

match(string, pos=0, endpos=sys.maxsize)
- Сопоставляет только с начала строки
- Возвращает Match или None
fullmatch(string, pos=0, endpos=sys.maxsize)
- Требует полного совпадения всей строки
search(string, pos=0, endpos=sys.maxsize)
- Ищет первое совпадение в любом месте
findall(string, pos=0, endpos=sys.maxsize)
- Возвращает список строк или кортежей (если групп > 1)
finditer(string, pos=0, endpos=sys.maxsize)
- Возвращает итератор Match

Замена и разбиение

sub(repl, string, count=0)
- repl: строка или вызываемый (lambda m: ...)
- \g<0>, \g<name>, \1, \g<1> — подстановка групп
subn(repl, string, count=0) → (new_string, n_subs)
split(string, maxsplit=0)
- Возвращает список фрагментов; совпадения не включаются
- Если группа в шаблоне — совпадения групп также включаются в результат

`Match` объект

group([group1, ...]) → строка или кортеж
groups(default=None) → кортеж всех групп
groupdict(default=None) → dict именованных групп
start([group]), end([group]), span([group])
expand(template) — как sub(), но только для одного совпадения

Синтаксис шаблонов (кратко)

. — любой символ (кроме \n, если не re.S)
^, $ — начало/конец строки (re.M → начало/конец строки в многострочном тексте)
\d, \D, \s, \S, \w, \W
[abc], [^abc], [a-z]
*, +, ?, {m,n}, {m,}, {,n}
(...), (?P<name>...), (?:...), (?=...), (?!...), (?<=...), (?<!...)
\A, \Z, \b, \B

Безопасность

Некоторые регулярные выражения вызывают катастрофический откат (catastrophic backtracking)
Используйте re.search() с ограничением по длине, либо сторонние движки (regex вместо re) при необходимости

2.16 `shutil` — Высокоуровневые операции с файлами

Копирование

copyfile(src, dst, *, follow_symlinks=True)
- Только содержимое, без метаданных
- dst — путь, не дескриптор
copymode(src, dst, *, follow_symlinks=True)
- Права доступа (chmod)
copystat(src, dst, *, follow_symlinks=True)
- Временные метки, права, ACL (если поддерживается)
copy(src, dst, *, follow_symlinks=True)
- copyfile() + copymode()
copy2(src, dst, *, follow_symlinks=True)
- copyfile() + copystat() — «полная» копия
copytree(src, dst, symlinks=False, ignore=None, copy_function=copy2, ignore_dangling_symlinks=False, dirs_exist_ok=False)
- Рекурсивно копирует дерево каталогов
- ignore — вызываемый: ignore(dir, names) → set(names_to_skip)
- dirs_exist_ok=True (Python ≥ 3.8) — разрешает существование dst

Перемещение и удаление

move(src, dst, copy_function=copy2)
- Атомарно при os.rename() (если на одной ФС), иначе копия + удаление
rmtree(path, ignore_errors=False, onerror=None)
- Рекурсивное удаление каталога
- onerror(function, path, exc_info) — для обработки ошибок
.rmtree.avoids_symlink_attacks — флаг (True на Unix с lstat)

Архивирование

make_archive(base_name, format, root_dir=None, base_dir=None, verbose=0, dry_run=0, owner=None, group=None, logger=None)
- format: 'zip', 'tar', 'gztar', 'bztar', 'xztar'
- Возвращает полный путь к архиву
get_archive_formats() → список поддерживаемых форматов
unpack_archive(filename, extract_dir=None, format=None)
- Автоопределение формата, если format=None

Прочее

which(cmd, mode=os.F_OK | os.X_OK, path=None)
- Ищет исполняемый файл в PATH, как which в оболочке
disk_usage(path) → namedtuple(total, used, free)
chown(path, user=None, group=None)
- Принимает имена или UID/GID
get_terminal_size(fallback=(80, 24)) → (columns, lines)
register_archive_format(name, function, ...)
register_unpack_format(name, extensions, function, ...)

2.17 `signal` — Обработка сигналов (Unix)

Константы сигналов

SIGINT, SIGTERM, SIGKILL, SIGSTOP, SIGHUP, SIGUSR1, SIGUSR2, SIGALRM, и др.
SIG_DFL, SIG_IGN, SIG_ERR

Управление

signal(signalnum, handler)
- handler: вызываемый (def handler(signum, frame): ...), SIG_DFL, SIG_IGN
- Возвращается предыдущий обработчик
getsignal(signalnum)
pause() — приостанавливает процесс до получения сигнала
alarm(seconds) → оставшееся время предыдущего таймера
setitimer(which, seconds, interval=0.0) — интервальные таймеры (ITIMER_REAL, ITIMER_VIRTUAL, ITIMER_PROF)
getitimer(which)
siginterrupt(signalnum, flag) — прерывать ли системные вызовы (EINTR)

Ограничения

Обработчики выполняются в основном потоке
Внутри обработчика допустимо только async-signal-safe API:
- signal(), write(), kill(), _exit(), getattr() на простых объектах
- Нельзя: print(), logging, sys.stdout.write() (если буферизован), threading, gc, sys.exit()
В Windows поддерживается только SIGINT, SIGBREAK, SIGABRT

2.18 `socket` — Сетевые сокеты

Константы

AF_INET, AF_INET6, AF_UNIX
SOCK_STREAM, SOCK_DGRAM, SOCK_RAW
SOL_SOCKET, IPPROTO_TCP, IPPROTO_UDP
SO_REUSEADDR, SO_REUSEPORT, SO_KEEPALIVE, TCP_NODELAY

Создание

socket(family=AF_INET, type=SOCK_STREAM, proto=0, fileno=None)
fromfd(fd, family, type, proto=0)
socketpair(family=AF_UNIX, type=SOCK_STREAM, proto=0)

Атрибуты

family, type, proto, fileno()

Основные методы

bind(address)
listen([backlog])
accept() → (conn, address)
connect(address)
connect_ex(address) → код ошибки (0 при успехе)
send(bytes[, flags]), sendall(bytes[, flags])
recv(bufsize[, flags]), recvfrom(bufsize[, flags])
sendto(bytes, address[, flags])
close(), detach()
shutdown(how) — SHUT_RD, SHUT_WR, SHUT_RDWR

Управление

setblocking(flag)
settimeout(value) — None (блокирующий), 0.0 (неблокирующий), >0 (таймаут)
gettimeout()
setsockopt(level, optname, value)
getsockopt(level, optname[, buflen])
getpeername(), getsockname()

Вспомогательные функции

gethostname()
gethostbyname(hostname)
getaddrinfo(host, port, family=0, type=0, proto=0, flags=0)
- Возвращает список (family, type, proto, canonname, sockaddr)
getnameinfo(sockaddr, flags)
inet_aton(ip_string), inet_ntoa(packed_ip)
inet_pton(address_family, ip_string), inet_ntop(address_family, packed_ip)

Исключения

error — базовый класс (OSError подкласс)
herror, gaierror, timeout

2.19 `subprocess` — Запуск дочерних процессов

`run(args, *, stdin=None, input=None, stdout=None, stderr=None, capture_output=False, timeout=None, check=False, encoding=None, errors=None, text=None, env=None, universal_newlines=None, **other_popen_kwargs)`

Рекомендуемый интерфейс
Возвращает CompletedProcess(args, returncode, stdout, stderr)
capture_output=True ⇔ stdout=PIPE, stderr=PIPE
text=True ⇔ encoding='utf-8' (или universal_newlines=True)
check=True → CalledProcessError, если returncode != 0
timeout → TimeoutExpired, если превышено

`Popen(args, bufsize=-1, executable=None, stdin=None, stdout=None, stderr=None, preexec_fn=None, close_fds=True, shell=False, cwd=None, env=None, universal_newlines=None, startupinfo=None, creationflags=0, restore_signals=True, start_new_session=False, pass_fds=(), *, encoding=None, errors=None, text=None)`

Низкоуровневый интерфейс
Методы:
- poll() → returncode или None
- wait(timeout=None)
- communicate(input=None, timeout=None) → (stdout, stderr)
- send_signal(signal), terminate(), kill()
- pid, returncode
shell=True — интерпретирует args как строку и запускает /bin/sh -c
preexec_fn — вызывается в дочернем процессе перед exec (только Unix)
pass_fds — передача дескрипторов (Unix)

Потокобезопасность и буферизация

stdout=PIPE не следует использовать при объёме > 64 КБ без communicate()
Для потоковой обработки — использовать asyncio.create_subprocess_* или threading + queue.Queue

2.20 `sys` — Системные параметры и функции

Атрибуты

argv — аргументы командной строки
path — пути поиска модулей
modules — кэш загруженных модулей
builtin_module_names — кортеж встроенных модулей
platform — 'linux', 'win32', 'darwin'
version, version_info, hexversion
implementation — namedtuple(name, version, _multiarch)
byteorder — 'little', 'big'
maxsize — максимальный int для Py_ssize_t (≈ 2**63-1)
stdin, stdout, stderr — файлоподобные объекты
__stdin__, __stdout__, __stderr__ — оригиналы (до переназначения)
ps1, ps2 — приглашения интерпретатора (только в интерактивном режиме)
flags — namedtuple флагов (debug, inspect, optimize, dont_write_bytecode, no_user_site, …)
float_info, int_info, hash_info, thread_info

Функции

exit([status]) — вызывает SystemExit
getsizeof(object[, default]) — размер в байтах (не рекурсивно)
getrefcount(object)
getfilesystemencoding(), getdefaultencoding()
getprofile(), setprofile(function)
gettrace(), settrace(function)
intern(string) — интернирование строк (экономия памяти для часто используемых строк)
setrecursionlimit(limit)
getrecursionlimit()
addaudithook(hook) — безопасный аудит событий (Python ≥ 3.8)
breakpointhook() — переопределяется через PYTHONBREAKPOINT

2.21 `threading` — Потоки

`Thread(group=None, target=None, name=None, args=(), kwargs={}, *, daemon=None)`

start(), join(timeout=None), is_alive()
name, ident, daemon
run() — переопределяется в подклассах

Примитивы синхронизации

Lock: acquire(blocking=True, timeout=-1), release(), locked()
RLock: рекурсивная блокировка
Condition(lock=None):
- acquire(), release()
- wait(timeout=None), wait_for(predicate, timeout=None)
- notify(n=1), notify_all()
Semaphore(value=1), BoundedSemaphore(value=1)
Event: set(), clear(), is_set(), wait(timeout=None)
Barrier(parties, action=None, timeout=None)
- wait(timeout=None) — блокирует до parties вызовов

Вспомогательные

current_thread()
active_count(), enumerate()
main_thread()
get_ident()
local() — потоколокальные данные (x = local(); x.v = 1)

Ограничения

GIL не позволяет параллельное исполнение Python-кода в нескольких потоках
Блокировки атомарны благодаря GIL
Для CPU-bound задач — использовать multiprocessing

2.22 `time` — Время

Функции

time() → float, секунды с epoch (1970-01-01 UTC)
monotonic() → монотонное время (нельзя использовать для дат, только для замеров)
perf_counter() → высокоточное время (лучше monotonic() для профилирования)
process_time() → время CPU текущего процесса
sleep(secs)
strftime(format[, t]), strptime(string[, format])
gmtime([secs]), localtime([secs]) → struct_time
mktime(t) — обратное localtime()
clock_gettime(clk_id), clock_settime(clk_id, time) (Unix)
- CLOCK_REALTIME, CLOCK_MONOTONIC, CLOCK_PROCESS_CPUTIME_ID, и др.

`struct_time`

Атрибуты: tm_year, tm_mon, tm_mday, tm_hour, tm_min, tm_sec, tm_wday, tm_yday, tm_isdst
Доступ по индексу и имени

Константы

timezone — смещение локального часового пояса от UTC (секунды, запад — положительно)
altzone — аналогично, для летнего времени
daylight — 1, если летнее время используется
tzname — ('CST', 'CDT')

2.23 `types` — Встроенные типы и утилиты

Типы

MappingProxyType(mapping) — read-only dict-обёртка
SimpleNamespace(**kwargs) — object с __dict__, __repr__, __eq__
CellType — ячейка замыкания
CodeType, FrameType, TracebackType, GeneratorType, CoroutineType, AsyncGeneratorType
MethodType(func, obj) — привязанный метод
BuiltinMethodType, WrapperDescriptorType, MethodDescriptorType, GetSetDescriptorType

Интроспекция

new_class(name, bases=(), kwds=None, exec_body=None)
resolve_bases(bases) — для метаклассов
GenericAlias — для list[int], dict[str, int]
UnionType — для int | str (Python ≥ 3.10)

2.24 `typing` — Поддержка аннотаций типов

Базовые

Any, Never, NoReturn
None, Literal[...], LiteralString
Union[T1, T2], Optional[T] == Union[T, None], T | U (Python ≥ 3.10)
Tuple[T, ...], List[T], Dict[K, V], Set[T], FrozenSet[T] (устаревшие, предпочтительно list[T], dict[K, V])
Sequence[T], Iterable[T], Iterator[T], Container[T], Callable[[T], R], Protocol, TypeVar, Generic, TypeGuard, ParamSpec, Concatenate, TypeAlias, TypedDict, Final, ClassVar, Annotated, Required, NotRequired, Unpack, Type, Self, assert_type, reveal_type, cast, overload, final, runtime_checkable, dataclass_transform

Примеры

T = TypeVar('T')
P = ParamSpec('P')
class C(Generic[T]): ...
def f(x: int | None) -> str: ...
MyDict = dict[str, list[int]]
@overload def f(x: int) -> str: ...
@final class A: ...

Совместимость

Аннотации не влияют на выполнение (кроме cast, assert_type)
Проверяются статическими анализаторами (mypy, pyright)
from __future__ import annotations — откладывает вычисление аннотаций

2.25 `unittest` — Фреймворк тестирования

`TestCase`

Методы: setUp(), tearDown(), setUpClass(), tearDownClass()
Утверждения:
- assertEqual(a, b), assertNotEqual(a, b)
- assertTrue(x), assertFalse(x)
- assertIs(a, b), assertIsNot(a, b)
- assertIn(a, b), assertNotIn(a, b)
- assertIsInstance(a, b), assertNotIsInstance(a, b)
- assertRaises(exc, callable, *args, **kwds)
- assertWarns(warn, callable, *args, **kwds)
- assertLogs(logger=None, level=None)
- assertAlmostEqual(a, b, places=7), assertNotAlmostEqual(...)
- assertRegex(s, r), assertNotRegex(s, r)
- assertMultiLineEqual(a, b)
- assertCountEqual(a, b)

Тест-раннеры

TestRunner.run(test)
TextTestRunner(verbosity=1, stream=sys.stderr, ...)
unittest.main() — запуск из __main__

Прочее

TestSuite, TestLoader, skip, skipIf, skipUnless, expectedFailure
mock.patch, mock.Mock, mock.MagicMock — встроены с Python 3.3 (unittest.mock)

2.26 `warnings` — Предупреждения

Функции

warn(message, category=UserWarning, stacklevel=1, source=None)
warn_explicit(message, category, filename, lineno, module=None, registry=None, module_globals=None)
simplefilter(action, category=Warning, lineno=0, append=False)
filterwarnings(action, message='', category=Warning, module='', lineno=0, append=False)
resetwarnings()

Действия

'default' — печатать первое предупреждение в модуле
'error' → исключение
'ignore'
'always' — печатать всегда
'module' — первое в модуле
'once' — первое глобально

📘 Часть 3. Экосистема Python

3.1 Веб-фреймворки

`Django` (синхронный full-stack)

Основные компоненты:
- django.core.management.execute_from_command_line() — точка входа CLI
- django.conf.settings — lazy-объект конфигурации
- django.urls.path(route, view, kwargs=None, name=None), re_path()
- django.http.HttpRequest, HttpResponse, JsonResponse
- django.views.generic.View, TemplateView, ListView, DetailView, CreateView, и др.
Модели:
- models.Model: поля (CharField, IntegerField, ForeignKey, ManyToManyField, JSONField, UUIDField, и т.д.)
- Мета-опции: db_table, ordering, indexes, constraints, verbose_name, unique_together
- QuerySet API: filter(), exclude(), annotate(), aggregate(), select_related(), prefetch_related(), only(), defer(), bulk_create(), update(), delete()
Админка:
- admin.ModelAdmin: list_display, list_filter, search_fields, inlines, readonly_fields, get_queryset()
Безопасность:
- django.middleware.csrf.CsrfViewMiddleware
- django.contrib.auth — пользователи, группы, права
- @login_required, @permission_required, user_passes_test()

`Flask` (микрофреймворк)

Flask(__name__, static_url_path, static_folder, template_folder, instance_relative_config=False)
Декораторы:
- @app.route(rule, methods=['GET'], endpoint=None)
- @app.before_request, @app.after_request, @app.teardown_request
- @app.errorhandler(code_or_exception)
Контексты:
- request, session, g, current_app
Расширения:
- Flask-SQLAlchemy: db = SQLAlchemy(app)
- Flask-Migrate: migrate = Migrate(app, db)
- Flask-Login: login_user(), current_user, @login_required
- Flask-CORS: CORS(app)
Конфигурация: app.config.from_object(), from_pyfile(), from_envvar()

`FastAPI` (асинхронный, на основе `Starlette` и `Pydantic`)

FastAPI(title, description, version, openapi_url, docs_url, redoc_url, ...)
Маршрутизация:
- @app.get("/items/{item_id}")
- Поддержка async def
Валидация и документация:
- Параметры: Path(...), Query(...), Header(...), Cookie(...), Body(...)
- Ответы: response_model, status_code, responses={404: {"model": Error}}
- Depends() — внедрение зависимостей:
```
def get_db(): ...
def read_items(db: Session = Depends(get_db)): ...
```
OpenAPI/Swagger: автоматическая генерация /docs, /redoc, /openapi.json
Поддержка WebSocket: @app.websocket("/ws")
Совместимость: WSGI (uvicorn.run(app, ...)), ASGI напрямую

`Starlette` (низкоуровневая основа FastAPI)

Request, Response, JSONResponse, PlainTextResponse, HTMLResponse, RedirectResponse, StreamingResponse, FileResponse
Роутинг: Router, Mount, Host, WebSocketRoute, Route
Middleware: Middleware, CORSMiddleware, SessionMiddleware, AuthenticationMiddleware
Тестирование: TestClient(app)

`ASGI-серверы`

uvicorn.run(app, host="127.0.0.1", port=8000, reload=False, workers=1, loop="auto", http="auto", ws="auto", lifespan="auto", interface="asgi3", debug=False, ...)
hypercorn.run(app, ...) — поддержка HTTP/2, graceful shutdown
daphne — для channels

3.2 ORM и работа с БД

`SQLAlchemy` (реляционные БД)

Режимы:
- Core — SQL Expression Language
- ORM — маппинг объектов
create_engine(url, echo=False, pool_size=5, max_overflow=10, ...)
Session = sessionmaker(bind=engine), session = Session()

ORM-модель:

class User(Base):
    __tablename__ = 'users'
    id = Column(Integer, primary_key=True)
    name = Column(String(50), nullable=False)
    emails = relationship("Email", back_populates="user")

Запросы:
- session.query(User).filter(User.name == '...').first() (Legacy)
- select(User).where(User.name == '...') (2.0-style)
- session.execute(stmt).scalars().all()
Поддержка асинхронности: create_async_engine, AsyncSession, await session.execute(...)
Миграции: Alembic — alembic init, revision --autogenerate, upgrade head

`Pydantic` (валидация и сериализация)

BaseModel
Поля: Field(default=..., alias=..., ge=0, le=100, pattern=r'^\w+$')
Валидация:
- @validator('name', pre=True)
- @root_validator
- model_config = ConfigDict(extra='forbid', frozen=True, strict=True)
Сериализация:
- .model_dump(), .model_dump_json()
- .model_validate(obj), .model_validate_json(json_str)
Поддержка Generic, Union, Literal, Annotated, Field, computed_field
Интеграция: FastAPI, SQLModel, MongoEngine, Django Ninja

`SQLModel` (SQLAlchemy + Pydantic)

class Hero(SQLModel, table=True): id: int = Field(default=None, primary_key=True)
Единая модель для ORM и API
Поддержка select(), session.exec(select(...))
Совместим с FastAPI «из коробки»

`MongoEngine` (MongoDB, документная)

Document, EmbeddedDocument
Поля: StringField, IntField, ListField, ReferenceField, DateTimeField, ObjectIdField
Запросы: User.objects(name="...").first(), User.objects(age__gte=18)
Индексы: meta = {'indexes': ['name', ('age', '-created')]}
Соединение: connect('db', host='localhost', port=27017)

`Tortoise ORM` (асинхронный ORM)

Определение:

class User(Model):
    id = fields.IntField(pk=True)
    name = fields.CharField(max_length=50)

Инициализация: await Tortoise.init(db_url="sqlite://db.sqlite3", modules={"models": ["__main__"]})
Запросы: await User.filter(name="...").first(), await User.create(...), await user.save()
Миграции: aerich init, aerich migrate, aerich upgrade

3.3 Асинхронное программирование (помимо `asyncio`)

`httpx` (асинхронный HTTP-клиент)

AsyncClient(base_url=None, headers=None, timeout=5.0, ...)
Методы: get(), post(), put(), delete(), stream()
Поддержка:
- HTTP/2 (с httpx[http2])
- соединения: client = AsyncClient(); await client.get(...); await client.aclose()
- таймауты: timeout=httpx.Timeout(5.0, connect=2.0)
Синхронный интерфейс: httpx.Client()

`aiohttp`

aiohttp.ClientSession() — сессия
session.get(...), session.post(...)
aiohttp.web.Application() — сервер
WebSocket: ws = aiohttp.web.WebSocketResponse()

`trio`

async with trio.open_nursery() as nursery: nursery.start_soon(...)
Отмена: with trio.move_on_after(5): ...
Каналы: send_channel, receive_channel = trio.open_memory_channel(0)
trio.run(main) — точка входа

3.4 Обработка данных

`pandas`

DataFrame(data=None, index=None, columns=None, dtype=None, copy=False)
Конструкторы:
- pd.read_csv(), read_json(), read_sql(), read_excel(), read_parquet(), read_pickle()
- pd.DataFrame.from_dict(), .from_records()
Индексация:
- .loc[rows, cols], .iloc[pos], .at[label, col], .iat[pos, col]
Операции:
- groupby(), agg(), transform(), apply()
- merge(), join(), concat()
- pivot(), melt(), stack(), unstack()
Пропуски: isna(), dropna(), fillna(), interpolate()
Временные ряды: resample(), rolling(), shift(), diff()
Производительность: dtypes, categorical, query(), eval()

`NumPy`

array(object, dtype=None, copy=True, order='K', ...)
Типы: int32, int64, float32, float64, bool_, complex128, object_
Формы: shape, ndim, size, T, reshape(), ravel(), flatten()
Создание: zeros(), ones(), empty(), arange(), linspace(), logspace(), meshgrid()
Операции:
- Универсальные: +, -, *, /, **, sin, cos, exp, log, sqrt
- Свёртка: sum(), prod(), mean(), std(), var(), min(), max(), argmin(), argmax()
- По оси: axis=0 (столбцы), axis=1 (строки)
Линейная алгебра: @, dot(), matmul(), linalg.inv(), linalg.solve(), linalg.eig()

`polars` (альтернатива pandas, Rust-ядро)

pl.DataFrame(data), pl.from_pandas(df)
Lazy API: df.lazy().filter(...).group_by(...).agg(...).collect()
Оптимизации: pushdown predicate, column pruning
Поддержка: Arrow, Parquet, CSV, JSON, IPC

3.5 CLI и инструменты разработки

`click`

@click.group(), @click.command()
Параметры:
- @click.argument('name', type=str)
- @click.option('--count', '-c', default=1, type=int)
- @click.option('--verbose/--no-verbose', default=False)
- @click.option('--file', type=click.File('r'))
Подкоманды:
```
@cli.command()
def init(): ...
```
Контекст: @click.pass_context, ctx.obj

`typer` (на основе `click`, типизированный)

app = typer.Typer()
@app.command()

Аннотации:

def main(name: str, count: int = 1, verbose: bool = False):

Поддержка Annotated, Union, Enum, Path, FileText
Автогенерация CLI из функций

`rich`

print() → rich.print()
console = Console(), console.print(...), console.log(...), console.rule()
Таблицы: Table(), table.add_column(), table.add_row()
Прогресс: with Progress() as progress: task = progress.add_task("...", total=100)
Панель, дерево, markdown, traceback: inspect(obj), Traceback(), Syntax(code, "python")

`loguru`

logger.add("file.log", rotation="500 MB", retention="10 days", compression="zip", level="INFO")
logger.info("msg {x}", x=1)
Поддержка: цвета, traceback, opt(exception=True), patch(lambda r: r["extra"].update(...))
Замена logging: logger.remove(); logger.add(sys.stderr)

3.6 Тестирование

`pytest`

Фикстуры: @pytest.fixture, autouse=True, scope="function"/"module"/"session"
Параметризация: @pytest.mark.parametrize("a,b", [(1,2), (3,4)])
Маркеры: @pytest.mark.skip, @pytest.mark.xfail, @pytest.mark.slow
Плагины:
- pytest-cov — покрытие
- pytest-asyncio — @pytest.mark.asyncio
- pytest-mock — mocker фикстура
Конфигурация: pytest.ini, pyproject.toml

`hypothesis`

@given(st.integers(), st.text())
Стратегии: st.lists(), st.dictionaries(), st.builds(MyClass), st.from_type(MyClass)
Настройка: settings(max_examples=100, deadline=1000)
Интеграция с pytest

3.7 Кэширование

`redis-py`

redis.Redis(host='localhost', port=6379, db=0, password=None, ...)
Операции:
- get(key), set(key, value, ex=60), mget(), mset()
- hgetall(key), hset(key, mapping={})
- lpush(), rpop(), blpop()
- sadd(), smembers(), zadd(), zrange()

Пайплайны:

with r.pipeline() as pipe:
    pipe.set('a', 1)
    pipe.get('a')
    res = pipe.execute()

Асинхронный: redis.asyncio.Redis()

`cachetools` (in-memory)

LRUCache(maxsize, getsizeof=None)
TTLCache(maxsize, ttl, timer=time.monotonic)
cached(cache, key=lambda args, kwargs: hash(args))
cachedmethod(cache) — для методов

3.8 Сериализация

`orjson`

orjson.dumps(obj, option=orjson.OPT_INDENT_2 | orjson.OPT_SORT_KEYS)
Поддержка: datetime, uuid, dataclass, numpy, pandas (частично)
Опции: OPT_NAIVE_UTC, OPT_UTC_Z, OPT_OMIT_MICROSECONDS
loads() — быстрее json.loads

`msgpack`

msgpack.packb(obj, use_bin_type=True)
msgpack.unpackb(data, raw=False)
Бинарный, компактный, кросс-платформенный

3.9 Аутентификация и авторизация

`authlib`

Универсальный инструмент для OAuth, OpenID Connect, JWT, JWS, JWE.

OAuth2Client(client_id, client_secret, token_url, ...)
jwt.encode(header, payload, key, algorithm='HS256')
jwt.decode(token, key, algorithms=['HS256'], audience=None, issuer=None)
Поддержка client_credentials, authorization_code, implicit, password грантов
Интеграция: Flask, Django, Starlette, FastAPI через authlib.integrations

`pyjwt`

jwt.encode(payload, key, algorithm='HS256', headers=None)
jwt.decode(token, key, algorithms=['HS256'], options={'verify_signature': True, 'verify_exp': True})
Алгоритмы: HS256, RS256, ES256, PS256
Поддержка leeway для временных допусков
Безопасность: рекомендуется явно указывать algorithms, избегать verify=False

`django-allauth`

Поддержка: локальный логин + OAuth (Google, GitHub, Facebook, и др.)
URL-паттерны: path('accounts/', include('allauth.urls'))
Настройки:
- ACCOUNT_EMAIL_REQUIRED = True
- ACCOUNT_EMAIL_VERIFICATION = 'mandatory'
- SOCIALACCOUNT_PROVIDERS = { 'google': { 'SCOPE': ['profile', 'email'] } }
Signals: user_logged_in, user_signed_up, social_account_added

`oauthlib`

Низкоуровневая реализация OAuth1/OAuth2.

WebApplicationServer — для authorization_code
MobileApplicationServer — для implicit
LegacyApplicationServer — для password
TokenEndpoint, AuthorizationEndpoint — составные части
Не включает HTTP-транспорт — используется в связке с requests-oauthlib, authlib, Django OAuth Toolkit

3.10 Валидация данных

`pydantic` (уже частично описан, дополнения)

Модели:

class User(BaseModel):
    id: int
    name: str = Field(min_length=1, max_length=100)
    email: EmailStr
    tags: list[str] = []
    created_at: datetime = Field(default_factory=datetime.utcnow)

Валидаторы:
- @field_validator('email', mode='before') — предварительно
- @model_validator(mode='after') — после инициализации

Конфигурация:

model_config = ConfigDict(
    extra='forbid',
    frozen=True,
    strict=True,
    populate_by_name=True,
    alias_generator=to_camel,
    json_schema_extra={'examples': [...]}
)

Сериализация:
- .model_dump(mode='json') — преобразует datetime, UUID, Decimal в JSON-совместимые
- .model_dump_json(indent=2, exclude_unset=True)
Производительность: pydantic-core (Rust-ядро) ускоряет валидацию в ~5–10×

`cerberus`

Схема как словарь:

schema = {
    'name': {'type': 'string', 'required': True, 'minlength': 1},
    'age': {'type': 'integer', 'min': 0, 'max': 150},
    'tags': {'type': 'list', 'schema': {'type': 'string'}}
}
v = Validator(schema)
v.validate({'name': 'Timur', 'age': 30})  # → True
v.errors  # → {}

Поддержка: coerce, rename, default, allowed, regex, вложенные схемы
Не использует аннотации типов — полностью декларативен

`jsonschema`

Поддержка Draft 7, 2019-09, 2020-12

Валидация:

from jsonschema import validate, Draft202012Validator
schema = {"type": "object", "properties": {"name": {"type": "string"}}, "required": ["name"]}
validate(instance={"name": "Timur"}, schema=schema)

Кастомизация:
- Draft202012Validator(schema).iter_errors(instance) — ленивая проверка
- FormatChecker — для email, date-time, uri, и др.
Интеграция: OpenAPI/Swagger, JSON Schema Store

3.11 Тестирование (дополнения)

`pytest` (расширенные фичи)

Фикстуры:
- scope='session' — одна на весь запуск
- autouse=True — автоматически включается
- yield — teardown:
```
@pytest.fixture
def db():
    db = connect()
    yield db
    db.close()
```

Параметризация по файлам/директориям:

@pytest.mark.parametrize("case", load_test_cases("cases/*.json"))
def test_api(case):
    ...

Кастомные маркеры:

# conftest.py
def pytest_configure(config):
    config.addinivalue_line("markers", "slow: marks tests as slow")

Плагин pytest-asyncio:
- @pytest.mark.asyncio
- loop_scope='function' (новое в 0.23+) — позволяет разделять event loop между тестами

`hypothesis`

Стратегии:
- st.text(), st.integers(min_value=0), st.floats(allow_nan=False)
- st.lists(st.text(), min_size=1, unique=True)
- st.builds(MyModel, name=st.text(), age=st.integers(0, 120))

Настройка:

@given(st.text())
@settings(max_examples=1000, deadline=500)  # ms
def test_upper_lower(text):
    assert text.upper().lower() == text.lower()

Интеграция: pytest, unittest, unittest.TestCase через @given как декоратор метода

`factory_boy`

Определение:

class UserFactory(factory.Factory):
    class Meta:
        model = User
    name = factory.Faker('name')
    email = factory.LazyAttribute(lambda o: f'{o.name.lower()}@example.com')
    is_active = True

Использование:
- UserFactory() → один экземпляр
- UserFactory.create_batch(5)
- UserFactory.build() — без сохранения в БД
Поддержка: Django (DjangoModelFactory), SQLAlchemy (SQLAlchemyModelFactory), peewee, mongoengine

3.12 Задачи и фоновая обработка

`celery`

Брокеры: Redis, RabbitMQ, Amazon SQS

Конфигурация:

app = Celery('proj', broker='redis://localhost', backend='redis://localhost')
app.conf.update(
    task_serializer='json',
    accept_content=['json'],
    result_serializer='json',
    timezone='UTC',
    enable_utc=True,
)

Задачи:

@app.task(bind=True, max_retries=3)
def send_email(self, to, subject):
    try:
        ...
    except Exception as exc:
        raise self.retry(exc=exc, countdown=60 * (2 ** self.request.retries))

Отслеживание:
- task.delay(...), task.apply_async(args=..., countdown=10), task.signature(...)
- AsyncResult(task_id).get(timeout=10)
Мониторинг: flower — веб-интерфейс с графиками, статистикой, управлением

`rq` (Redis Queue)

Простота:

from rq import Queue
from redis import Redis
q = Queue(connection=Redis())
job = q.enqueue(send_email, 'user@example.com', 'Hello')
job.result  # после завершения

Воркеры: rq worker
Поддержка: @job('high'), job.timeout = 60, job.retries = 3
Плагины: rq-scheduler — отложенные задачи, django-rq — интеграция с Django

`dramatiq`

Акцент на надёжность:
- Автоматический повтор при падении процесса
- Акторы как задачи
Брокеры: Redis, RabbitMQ
Middleware: AgeLimit, Callbacks, CurrentMessage, Prometheus, Retries, TimeLimit

Пример:

@dramatiq.actor(max_retries=3, time_limit=10000)
def compute(data):
    return heavy_computation(data)
compute.send(data)

3.13 Сериализация

`marshmallow`

Схемы:

class UserSchema(Schema):
    name = fields.Str(required=True, validate=validate.Length(min=1))
    email = fields.Email()
    created_at = fields.DateTime(dump_only=True)
    
    @post_load
    def make_user(self, data, **kwargs):
        return User(**data)

Использование:
- schema.load(data) → объект (или ValidationError)
- schema.dump(obj) → dict
Поддержка: вложенные схемы (Nested), списки (List(Nested(...))), pre_load, post_dump, validates_schema
Интеграция: Flask, Django, SQLAlchemy через marshmallow-sqlalchemy

`orjson`

Высокая производительность:
- Сериализация в ~2–5× быстрее ujson, json
- Десериализация ~1.5–2× быстрее
Поддержка:
- datetime, date, time, UUID, dataclass, namedtuple, Enum, numpy (скаляры, ndarray с .tolist())

Опции:

orjson.dumps(obj,
             option=orjson.OPT_NAIVE_UTC | orjson.OPT_UTC_Z | orjson.OPT_SERIALIZE_NUMPY)

Безопасность: не поддерживает произвольные __dict__ или __getattr__ — только явные типы

`msgpack`

Бинарный формат: компактнее JSON, быстрее парсится
Установка: pip install msgpack

Использование:

packed = msgpack.packb({'a': 1, 'b': [1, 2, 3]}, use_bin_type=True)
unpacked = msgpack.unpackb(packed, raw=False)

Поддержка: datetime через ext-типы (msgpack.ExtType), кастомные типы через default, ext_hook

3.14 CLI и интерактивные инструменты

`rich` (дополнения)

Таблицы:

table = Table(title="Users")
table.add_column("Name", style="cyan")
table.add_column("Age", justify="right")
table.add_row("Timur", "30")
console.print(table)

Прогресс:

with Progress() as progress:
    task = progress.add_task("[green]Processing...", total=100)
    for i in range(100):
        time.sleep(0.01)
        progress.update(task, advance=1)

Markdown, Syntax, Traceback:

console.print(Markdown("# Hello"), Syntax("print('hi')", "python"), Traceback())

Журналирование: RichHandler(show_time=True, show_path=True, enable_link_path=True)

`click` vs `typer`

Критерий	`click`	`typer`
Типизация	Необязательна	Обязательна (на основе аннотаций)
Вложенность команд	`@cli.group() → @group.command()`	`app = typer.Typer(); sub = typer.Typer(); app.add_typer(sub)`
Автодокументация	`--help` генерируется	То же + поддержка `Enum`, `Path`, `FileText`
Поддержка async	Через `asyncio.run()`	`@app.command()` + `async def` напрямую
Генерация shell-автодополнения	`eval "$(_CLI_COMPLETE=zsh_source cli)"`	`typer --install-completion`

3.15 DevOps и инфраструктура

`ansible`

Inventory: hosts.ini или hosts.yaml

Playbook:

- name: Deploy app
  hosts: webservers
  tasks:
    - name: Ensure directory exists
      file:
        path: /opt/app
        state: directory
        mode: '0755'
    - name: Copy files
      copy:
        src: ./dist/
        dest: /opt/app/
    - name: Restart service
      systemd:
        name: app.service
        state: restarted

Модули: copy, template, file, package, service, uri, shell, command
Динамические inventory: aws_ec2, azure_rm, gcp_compute

`supervisor`

Конфиг /etc/supervisor/conf.d/app.conf:

[program:app]
command=/venv/bin/gunicorn app:app -b 0.0.0.0:8000
directory=/opt/app
user=www-data
autostart=true
autorestart=true
redirect_stderr=true
stdout_logfile=/var/log/app.log
environment=PATH="/venv/bin"

Управление: supervisorctl reread, update, start app, status

`psutil`

Процессы:
- psutil.Process(pid).cpu_percent(interval=1), .memory_info(), .children(recursive=True)
Система:
- psutil.cpu_percent(percpu=True), .virtual_memory(), .disk_usage('/'), .net_io_counters()
Утилиты:
- psutil.sensors_temperatures(), .sensors_fans(), .sensors_battery()
Кроссплатформенность: Windows, Linux, macOS, FreeBSD

3.16 Наука и анализ

`scikit-learn`

Пайплайны:

pipe = Pipeline([
    ('scaler', StandardScaler()),
    ('pca', PCA(n_components=10)),
    ('clf', LogisticRegression())
])
pipe.fit(X_train, y_train)

Модели:
- LinearRegression, LogisticRegression, RandomForestClassifier, SVC, KMeans, DBSCAN
Валидация:
- cross_val_score(pipe, X, y, cv=5)
- GridSearchCV, RandomizedSearchCV
Метрики:
- accuracy_score, precision_recall_fscore_support, roc_auc_score, mean_squared_error

`PyTorch`

Тензоры:
- torch.tensor([1, 2, 3]), .cuda(), .to(device), .requires_grad_(True)

Модель:

class Net(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc = nn.Linear(10, 1)
    def forward(self, x):
        return self.fc(x)

Обучение:

model.train()
for batch in dataloader:
    optimizer.zero_grad()
    loss = criterion(model(batch.x), batch.y)
    loss.backward()
    optimizer.step()

DataLoader:
- DataLoader(dataset, batch_size=32, shuffle=True, num_workers=4, pin_memory=True)

`pandas` (дополнения)

Производительность:
- df.eval('a + b * c') — быстрее Python-цикла
- df.query('x > 0 and y < 10')
- pd.read_csv(..., dtype={'col': 'category'}, low_memory=False)
Пропуски:
- df.interpolate(method='linear'), .fillna(method='ffill')
- pd.isna(), pd.notna()

Группировка с кастомными функциями:

df.groupby('category').agg(
    mean=('value', 'mean'),
    std=('value', 'std'),
    count=('value', 'size'),
    custom=('value', lambda x: x.quantile(0.95))
)

3.17 GUI Development (расширенное покрытие)

`PyQt6` / `PySide6`

Создание приложения:

app = QApplication(sys.argv)
window = QMainWindow()
window.setWindowTitle("Title")
window.setGeometry(100, 100, 800, 600)

Виджеты:
- QLabel, QPushButton, QLineEdit, QTextEdit, QComboBox, QListWidget, QTableWidget, QTreeWidget
- QVBoxLayout, QHBoxLayout, QGridLayout, QFormLayout — компоновка

Сигналы и слоты:

button.clicked.connect(on_click)
line_edit.textChanged.connect(on_text_change)

Модальные окна:
- QDialog, QMessageBox.information(), .question(), .warning(), .critical()
Стилизация:
- widget.setStyleSheet("color: red; font-size: 14px;")
- Поддержка QSS (Qt Style Sheets), совместимого с CSS
Модели-представления:
- QStandardItemModel, QAbstractTableModel, QAbstractListModel
- QTableView, QListView, QTreeView
Асинхронность:
- QTimer.singleShot(0, callback) — возврат в event loop
- QThread + сигналы — без блокировки UI
- Интеграция с asyncio: qasync (сторонняя библиотека)

`Flet`

Архитектура: клиент-сервер (веб, нативный, мобильный)

Базовый шаблон:

import flet as ft

def main(page: ft.Page):
    page.title = "Flet app"
    page.add(ft.Text("Hello, world!"))

ft.app(target=main)  # локально
# ft.app(target=main, view=ft.WEB_BROWSER)  # браузер
# ft.app(target=main, port=8000)  # веб-сервер

Компоненты: Text, TextField, ElevatedButton, Column, Row, Container, Image, AppBar, Banner
Состояние: обновление через page.update() или автоматически при изменении Control
Роутинг: page.route = "/home" + page.on_route_change
Деплой: flet build windows/mac/linux/web/android/ios, flet deploy

`DearPyGui`

GPU-ускоренный, императивный стиль:

import dearpygui.dearpygui as dpg

dpg.create_context()
dpg.create_viewport(title='DearPyGui', width=600, height=400)
dpg.setup_dearpygui()

with dpg.window(label="Main"):
    dpg.add_text("Hello, world!")
    dpg.add_button(label="Click", callback=lambda: print("Clicked"))

dpg.show_viewport()
dpg.start_dearpygui()
dpg.destroy_context()

Поддержка: графики (add_plot, add_line_series), таблицы, вкладки, drag-drop, темы
Низкоуровневый контроль: set_value, get_value, configure_item, bind_item_handler_registry

`Tkinter` (встроен)

Минимальный пример:

import tkinter as tk
root = tk.Tk()
tk.Label(root, text="Hello").pack()
tk.Button(root, text="Quit", command=root.quit).pack()
root.mainloop()

Геометрия: pack(), grid(), place()
События: widget.bind("<Button-1>", handler)
Диалоги: tkinter.messagebox, tkinter.filedialog, tkinter.colorchooser
Преимущества: встроен, кроссплатформен, лёгкий старт
Недостатки: устаревший внешний вид, ограниченная функциональность

3.18 Web Crawling & Content Extraction

`Scrapy`

Проект: scrapy startproject myproject

Паук:

class MySpider(scrapy.Spider):
    name = 'example'
    start_urls = ['https://example.com']

    def parse(self, response):
        for item in response.css('.item'):
            yield {
                'title': item.css('h2::text').get(),
                'url': item.css('a::attr(href)').get(),
            }
        next_page = response.css('a.next::attr(href)').get()
        if next_page:
            yield response.follow(next_page, self.parse)

Пайплайны:
- process_item(item, spider) — очистка, валидация, сохранение
Настройки (settings.py):
- ROBOTSTXT_OBEY = True
- CONCURRENT_REQUESTS = 16
- DOWNLOAD_DELAY = 1
- USER_AGENT = 'MyBot/1.0'
- FEEDS = {'items.json': {'format': 'json'}}
Middleware:
- UserAgentMiddleware, RetryMiddleware, HttpProxyMiddleware
Расширения:
- scrapy-splash — JavaScript-рендеринг
- scrapy-redis — распределённое выполнение

`Playwright`

Высокоуровневый, поддержка Chromium, Firefox, WebKit:

from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch(headless=False)
    page = browser.new_page()
    page.goto("https://example.com")
    page.wait_for_selector("h1")
    print(page.title())
    page.screenshot(path="screenshot.png")
    browser.close()

Асинхронный: await playwright.chromium.launch()
Возможности:
- Эмуляция устройства (page.emulate_media(media="screen"))
- Перехват запросов (page.route("**/*", handler))
- Аутентификация: context.add_cookies([...]), page.fill("input#login", ...), page.click("button#submit")
- Скачать файлы: with page.expect_download() as download_info: ...

`newspaper3k`

Извлечение статьи:

from newspaper import Article
article = Article('https://example.com/article')
article.download()
article.parse()
article.nlp()  # keywords, summary
print(article.title, article.text, article.keywords, article.summary)

Поддержка: мультиязычность, извлечение изображений, авторов, дат
Ограничения: не для динамических сайтов (SPA)

`requests-html`

Простая альтернатива:

from requests_html import HTMLSession
session = HTMLSession()
r = session.get('https://example.com')
r.html.render()  # запускает Chromium (требует установки)
titles = r.html.find('h1', first=True).text

XPath, CSS-селекторы, JavaScript-рендеринг через pyppeteer

3.19 Static Site Generators

`MkDocs`

Конфиг mkdocs.yml:

site_name: My Project
theme: readthedocs
nav:
  - Home: index.md
  - Guide: guide.md
plugins:
  - search
  - markdownextradata

Команды:
- mkdocs build → site/
- mkdocs serve — локальный сервер с hot-reload
Темы: mkdocs-material, readthedocs, windmill
Расширения Markdown: admonitions, footnotes, tables, task lists

`Pelican`

Поддержка reStructuredText и Markdown

Генерация:

pelican content -o output -s pelicanconf.py

Плагины: sitemap, neighbors, assets, minify
Темы: notmyidea, flex, alchemy

`Lektor`

CMS-подобный интерфейс
Админка: lektor server --admin → http://localhost:5000/admin
Модели данных: models/, шаблоны: templates/
Публикация: lektor deploy

3.20 Serialization (дополнения)

`ultrajson`

Высокая производительность:

import ujson
ujson.dumps(obj, ensure_ascii=False, escape_forward_slashes=False)
ujson.loads(json_str, precise_float=False)

precise_float=False — использует float вместо Decimal, быстрее
Поддержка: None, bool, int, float, str, list, dict

`pysimdjson`

Обёртка над simdjson (C++): парсинг JSON в 4–10× быстрее json.loads

Использование:

import pysimdjson
parser = pysimdjson.Parser()
obj = parser.parse(b'{"a": 1}')
# или
obj = pysimdjson.loads('{"a": 1}')

Безопасность: не поддерживает object_hook, parse_float, только строгий JSON

3.21 Hardware & Low-Level

`scapy`

Отправка пакетов:

from scapy.all import *
pkt = IP(dst="192.168.1.1")/ICMP()
reply = sr1(pkt, timeout=2)
if reply:
    reply.show()

Анализ:
- sniff(filter="tcp port 80", prn=lambda x: x.summary())
- wrpcap("capture.pcap", packets)
Поддержка: Ethernet, IP, TCP, UDP, ICMP, ARP, DNS, HTTP, TLS (частично)
Требует привилегий (sudo)

`pynput`

Клавиатура:

from pynput import keyboard
def on_press(key):
    print(f'{key} pressed')
listener = keyboard.Listener(on_press=on_press)
listener.start()

Мыши:

from pynput.mouse import Controller
mouse = Controller()
mouse.position = (100, 200)
mouse.click(Button.left, 1)

Кроссплатформенность: Windows, macOS, Linux (X11)

3.22 Shell & CLI Enhancements

`xonsh`

Python + Bash:

#!/usr/bin/env xonsh
for file in $(ls *.py):
    echo @(file.upper())

Переменные: $PATH, $HOME, $PWD — как в Python (os.environ)
Алиасы:
- aliases['ll'] = ['ls', '-lh']
- aliases['gitlog'] = lambda args: ![git --no-pager log @args]
Плагины: xontrib load prompt_ret_code autoxsh

`thefuck`

Использование: после ошибки — ввести fuck (или настроить ESC-ESC)

Пример:

$ git brnch
git: 'brnch' is not a git command...
$ fuck  # → git branch

Правила: ~200 встроенных (cd_parent, git_add, man_no_space, yarn_alias)

3.23 Code Analysis & Refactoring

`ruff`

Замена flake8 + isort + pydocstyle + часть pylint

Конфиг .ruff.toml:

select = ["E", "F", "I", "N", "UP"]
ignore = ["E501"]
line-length = 88
isort.required-imports = ["from __future__ import annotations"]

Команды:
- ruff check .
- ruff format . — форматирование (альтернатива black)
- ruff check --fix . — автоматическое исправление
Производительность: ~10–100× быстрее flake8

`Bowler`

Безопасный рефакторинг на основе LibCST:

from bowler import Query
Query("src/").select_function("old_name").rename("new_name").execute()

Паттерны: select_method, select_class, filter, modify, insert_after
Поддержка: dry-run, интерактивный режим

3.24 RESTful API Frameworks (дополнения)

`FastAPI` (расширенные возможности)

Зависимости уровня приложения:

def get_db():
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

app = FastAPI(dependencies=[Depends(get_db)])

Совместимость с OpenAPI:
- openapi_url="/openapi.json"
- docs_url="/docs" (Swagger UI), redoc_url="/redoc"
- openapi_tags=[{"name": "users", "description": "User management"}]

Метаданные моделей:

class User(BaseModel):
    name: str = Field(..., min_length=1, max_length=50, json_schema_extra={"example": "Timur"})

Обработка ошибок:

@app.exception_handler(ValidationError)
async def validation_exception_handler(request, exc):
    return JSONResponse(status_code=422, content={"detail": exc.errors()})

Поддержка async и sync:
- def вызывается в ThreadPoolExecutor автоматически
- async def — напрямую в event loop
Интеграция с SQLModel, Pydantic, ORJSONResponse, Uvicorn

`Django REST Framework (DRF)`

Сериализаторы:

class UserSerializer(serializers.ModelSerializer):
    class Meta:
        model = User
        fields = ['id', 'username', 'email']
    def validate_email(self, value):
        if 'spam' in value:
            raise serializers.ValidationError("Spam not allowed")
        return value

ViewSets:

class UserViewSet(viewsets.ModelViewSet):
    queryset = User.objects.all()
    serializer_class = UserSerializer
    permission_classes = [IsAuthenticated]
    filter_backends = [DjangoFilterBackend, SearchFilter]
    filterset_fields = ['is_active']
    search_fields = ['username', 'email']

Аутентификация:
- TokenAuthentication, SessionAuthentication, JWTAuthentication (через djangorestframework-simplejwt)
Пагинация:
- PageNumberPagination, LimitOffsetPagination, CursorPagination
- Настройка: PAGE_SIZE = 20, MAX_PAGE_SIZE = 100

`Flask-RESTful`

Ресурсы:

class UserResource(Resource):
    def get(self, user_id):
        return users.get(user_id), 200
    def post(self):
        args = parser.parse_args()
        user_id = users.create(args)
        return {'id': user_id}, 201
api.add_resource(UserResource, '/users/<int:user_id>')

Парсер аргументов:

parser = reqparse.RequestParser()
parser.add_argument('name', type=str, required=True)
parser.add_argument('age', type=int, default=18)

Расширения: flask-jwt-extended, flask-cors, flask-marshmallow

3.25 Серверлесс и облачные платформы

`Zappa`

Конфиг zappa_settings.json:

{
  "production": {
    "app_function": "app.app",
    "aws_region": "us-east-1",
    "profile_name": "default",
    "project_name": "myapp",
    "runtime": "python3.12",
    "s3_bucket": "zappa-xxxx"
  }
}

Команды:
- zappa deploy production
- zappa update production
- zappa tail production
Поддержка: WSGI, Django, Flask, Bottle
Лимиты: 15 минут выполнения, 250 МБ пакета (сжатый), 3 ГБ памяти

`AWS Lambda + Mangum`

Совместимость с ASGI:

from mangum import Mangum
from fastapi import FastAPI

app = FastAPI()
handler = Mangum(app)

Развёртывание через serverless, chalice, aws-cdk
Холодный старт → Provisioned Concurrency, SnapStart

3.26 Конфигурация приложений

`hydra`

Конфиг config.yaml:

db:
  driver: postgresql
  host: localhost
  port: 5432

Декоратор:

@hydra.main(version_base=None, config_path="conf", config_name="config")
def main(cfg: DictConfig) -> None:
    print(cfg.db.host)

Композиция: defaults: [db: postgresql, model: resnet]
Переопределения в CLI: python app.py db.host=prod.example.com

`python-decouple`

.env:

DEBUG=True
DATABASE_URL=postgresql://user:pass@localhost/db

Использование:

from decouple import config
DEBUG = config('DEBUG', default=False, cast=bool)
DATABASE_URL = config('DATABASE_URL')

Поддержка: .env, settings.ini, os.environ, Django settings.py

3.27 Текстовая обработка

`spacy`

Загрузка модели:

import spacy
nlp = spacy.load("en_core_web_sm")
doc = nlp("Apple is looking at buying U.K. startup for $1 billion")

Извлечение:
- doc.ents → Apple (ORG), U.K. (GPE), $1 billion (MONEY)
- token.pos_, token.dep_, token.head
Пайплайн: nlp.pipe(texts, batch_size=1000, n_process=4)

Кастомные компоненты:

@Language.component("custom_component")
def custom_component(doc):
    ...
    return doc
nlp.add_pipe("custom_component", last=True)

`nltk`

Скачивание данных: nltk.download('punkt'), 'stopwords', 'wordnet'
Токенизация: word_tokenize, sent_tokenize
Частеречная разметка: pos_tag(tokens)
Лемматизация: WordNetLemmatizer().lemmatize('went', 'v')
Стоп-слова: stopwords.words('english')

`textdistance`

Расстояния:

import textdistance
textdistance.levenshtein('test', 'text')  # 1
textdistance.jaro_winkler('test', 'text')  # 0.916...
textdistance.cosine('test', 'text')  # 0.5

Поддержка: hamming, damerau_levenshtein, jaccard, sorensen, overlap, sift4, и др.

3.28 Обработка видео

`moviepy`

Базовое редактирование:

from moviepy.editor import *
clip = VideoFileClip("input.mp4").subclip(10, 20)
txt_clip = TextClip("Hello", fontsize=70, color='white').set_position('center').set_duration(10)
final = CompositeVideoClip([clip, txt_clip])
final.write_videofile("output.mp4", fps=24)

Аудио: clip.audio.write_audiofile("audio.wav")
Экспорт GIF: clip.write_gif("anim.gif", fps=5)
Поддержка: маски, переходы, эффекты (fx), наложение

`vidgear`

Высокопроизводительное захватывание:

from vidgear.gears import CamGear
stream = CamGear(source=0).start()
while True:
    frame = stream.read()
    if frame is None:
        break
    cv2.imshow("Frame", frame)
stream.stop()

Потоковая передача: WebGear, NetGear (ZeroMQ)
Экспорт: WriteGear → MP4, MKV, HLS, DASH

3.29 Тестирование (дополнения)

`pytest` + `Schemathesis`

Автоматическое тестирование OpenAPI:

import schemathesis
schema = schemathesis.from_uri("http://localhost/openapi.json")

@schema.parametrize()
def test_api(case):
    response = case.call()
    case.validate_response(response)

Параметры: endpoint="/users", method="POST", tags=["users"]
Фаззинг: hypothesis.settings(max_examples=100)

`locust`

Тест пользовательской нагрузки:

from locust import HttpUser, task
class WebsiteUser(HttpUser):
    @task
    def index(self):
        self.client.get("/")
    @task(3)
    def profile(self):
        self.client.get("/profile")

Запуск: locust -f load_test.py --host=http://localhost:8000
Веб-интерфейс: http://localhost:8089

3.30 Управление пакетами

`uv` (Rust-ускоритель)

Команды:
- uv venv — создаёт виртуальное окружение
- uv pip install requests — устанавливает быстрее pip
- uv pip compile requirements.in -o requirements.txt — генерация фиксированных зависимостей
- uv pip sync requirements.txt — синхронизация окружения
Производительность:
- Установка torch в ~2–5× быстрее pip
- Решение зависимостей в ~10–50× быстрее pip-tools

`poetry`

Управление проектом:
- poetry init → pyproject.toml
- poetry add requests
- poetry install --no-dev
- poetry build → dist/project-0.1.0-py3-none-any.whl
Виртуальные окружения: изолированные, управляемые автоматически
Поддержка: group.dev.dependencies, scripts, plugins

3.31 Генерация фейковых данных

`faker`

Базовое использование:

from faker import Faker
fake = Faker('ru_RU')
fake.name()      # 'Иванов Иван Иванович'
fake.email()     # 'ivanov@example.com'
fake.phone_number()  # '+7 (912) 345-67-89'
fake.date_of_birth(minimum_age=18, maximum_age=90)

Провайдеры: address, job, credit_card, company, ssn, isbn
Локализация: 70+ локалей (en_US, de_DE, ja_JP, zh_CN, ru_RU)

`mimesis`

Аналог faker, но:

Чистый Python, без зависимостей

Поддержка Schema:

from mimesis.schema import Schema
from mimesis.locales import Locale
schema = Schema(schema=lambda: {
    'id': uuid(),
    'name': full_name(),
    'email': email(),
    'age': age(),
}, iterations=10)
schema.create()

Специализированные данные: Science, Cryptographic, Development, Datetime

3.32 Профилирование и мониторинг

`py-spy`

Непрерывное профилирование:

py-spy record -o profile.svg --pid 12345
py-spy top --pid 12345

Поддержка: native-раскадровки, --native, --gil
Без изменения кода — attach к запущенному процессу

`sentry-sdk`

Интеграция:

import sentry_sdk
sentry_sdk.init(
    dsn="https://...@sentry.io/12345",
    traces_sample_rate=1.0,
    profiles_sample_rate=1.0,
)

Автоматический захват: исключений, логов (logging), celery, django, fastapi, sqlalchemy

📘 Часть 1. Ядро языка Python
📘 Часть 2. Стандартная библиотека Python
📘 Часть 3. Экосистема Python

📘 Часть 1. Ядро языка Python​

1.1 Встроенные типы​

NoneType​

bool​

int​

float​

complex​

str​

bytes​

bytearray​

memoryview​

list​

tuple​

range​

dict​

set​

frozenset​

1.2 Встроенные вызываемые объекты и служебные типы​

type​

function​

builtin_function_or_method​

method​

classmethod​

staticmethod​

property​

module​

ellipsis​

slice​

mappingproxy​

weakref.ref​

weakref.proxy​

generator​

coroutine​

async_generator​

code​

frame​

traceback​

getset_descriptor​

method_descriptor, wrapper_descriptor​

1.3 Встроенные функции​

abs(x)​

aiter(async_iterable)​

all(iterable)​

any(iterable)​

ascii(object)​

bin(x)​

bool(x=False)​

breakpoint(*args, **kws)​

bytearray(source=b'', encoding=None, errors='strict')​

bytes(source=b'', encoding=None, errors='strict')​

callable(object)​

chr(i)​

classmethod(func)​

compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)​

complex(real=0, imag=0)​

delattr(object, name)​

dict(iterable=(), **kwargs)​

dir([object])​

divmod(a, b)​

enumerate(iterable, start=0)​

eval(expression, globals=None, locals=None)​

exec(object, globals=None, locals=None)​

filter(function, iterable)​

float(x=0.0)​

format(value, format_spec='')​

frozenset(iterable=())​

getattr(object, name[, default])​

globals()​

hasattr(object, name)​

hash(object)​

help([object])​

hex(x)​

id(object)​

input([prompt])​

int(x=0, base=10)​

isinstance(object, classinfo)​

issubclass(class, classinfo)​

iter(object[, sentinel])​

len(s)​

list(iterable=())​

📘 Часть 1. Ядро языка Python

1.1 Встроенные типы

`NoneType`

`bool`

`int`

`float`

`complex`

`str`

`bytes`

`bytearray`

`memoryview`

`list`

`tuple`

`range`

`dict`

`set`

`frozenset`

1.2 Встроенные вызываемые объекты и служебные типы

`type`

`function`

`builtin_function_or_method`

`method`

`classmethod`

`staticmethod`

`property`

`module`

`ellipsis`

`slice`

`mappingproxy`

`weakref.ref`

`weakref.proxy`

`generator`

`coroutine`

`async_generator`

`code`

`frame`

`traceback`

`getset_descriptor`

`method_descriptor`, `wrapper_descriptor`

1.3 Встроенные функции

`abs(x)`

`aiter(async_iterable)`

`all(iterable)`

`any(iterable)`

`ascii(object)`

`bin(x)`

`bool(x=False)`

`breakpoint(*args, **kws)`

`bytearray(source=b'', encoding=None, errors='strict')`

`bytes(source=b'', encoding=None, errors='strict')`

`callable(object)`

`chr(i)`

`classmethod(func)`

`compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)`

`complex(real=0, imag=0)`

`delattr(object, name)`

`dict(iterable=(), **kwargs)`

`dir([object])`

`divmod(a, b)`

`enumerate(iterable, start=0)`

`eval(expression, globals=None, locals=None)`

`exec(object, globals=None, locals=None)`

`filter(function, iterable)`

`float(x=0.0)`

`format(value, format_spec='')`

`frozenset(iterable=())`

`getattr(object, name[, default])`

`globals()`

`hasattr(object, name)`

`hash(object)`

`help([object])`

`hex(x)`

`id(object)`

`input([prompt])`

`int(x=0, base=10)`

`isinstance(object, classinfo)`

`issubclass(class, classinfo)`

`iter(object[, sentinel])`

`len(s)`

`list(iterable=())`